0001: package org.tigris.scarab.om;
0002:
0003: import java.math.BigDecimal;
0004: import java.sql.Connection;
0005: import java.util.ArrayList;
0006: import java.util.Collections;
0007: import java.util.Date;
0008: import java.util.List;
0009:
0010: import org.apache.commons.lang.ObjectUtils;
0011: import org.apache.fulcrum.intake.Retrievable;
0012: import org.apache.torque.TorqueException;
0013: import org.apache.torque.om.BaseObject;
0014: import org.apache.torque.om.ComboKey;
0015: import org.apache.torque.om.DateKey;
0016: import org.apache.torque.om.NumberKey;
0017: import org.apache.torque.om.ObjectKey;
0018: import org.apache.torque.om.SimpleKey;
0019: import org.apache.torque.om.StringKey;
0020: import org.apache.torque.om.Persistent;
0021: import org.apache.torque.util.Criteria;
0022: import org.apache.torque.util.Transaction;
0023:
0024: /**
0025: * You should not use this class directly. It should not even be
0026: * extended all references should be to IssueType
0027: */
0028: public abstract class BaseIssueType extends BaseObject implements
0029: org.apache.fulcrum.intake.Retrievable {
0030: /** The Peer class */
0031: private static final IssueTypePeer peer = new IssueTypePeer();
0032:
0033: /** The value for the issueTypeId field */
0034: private Integer issueTypeId;
0035:
0036: /** The value for the name field */
0037: private String name;
0038:
0039: /** The value for the description field */
0040: private String description;
0041:
0042: /** The value for the parentId field */
0043: private Integer parentId;
0044:
0045: /** The value for the dedupe field */
0046: private boolean dedupe = true;
0047:
0048: /** The value for the deleted field */
0049: private boolean deleted = false;
0050:
0051: /** The value for the locked field */
0052: private boolean locked = false;
0053:
0054: /** The value for the isdefault field */
0055: private boolean isdefault = false;
0056:
0057: /**
0058: * Get the IssueTypeId
0059: *
0060: * @return Integer
0061: */
0062: public Integer getIssueTypeId() {
0063: return issueTypeId;
0064: }
0065:
0066: /**
0067: * Set the value of IssueTypeId
0068: *
0069: * @param v new value
0070: */
0071: public void setIssueTypeId(Integer v) throws TorqueException {
0072:
0073: if (!ObjectUtils.equals(this .issueTypeId, v)) {
0074: this .issueTypeId = v;
0075: setModified(true);
0076: }
0077:
0078: // update associated AttributeGroup
0079: if (collAttributeGroups != null) {
0080: for (int i = 0; i < collAttributeGroups.size(); i++) {
0081: ((AttributeGroup) collAttributeGroups.get(i))
0082: .setIssueTypeId(v);
0083: }
0084: }
0085:
0086: // update associated Issue
0087: if (collIssues != null) {
0088: for (int i = 0; i < collIssues.size(); i++) {
0089: ((Issue) collIssues.get(i)).setTypeId(v);
0090: }
0091: }
0092:
0093: // update associated RModuleIssueType
0094: if (collRModuleIssueTypes != null) {
0095: for (int i = 0; i < collRModuleIssueTypes.size(); i++) {
0096: ((RModuleIssueType) collRModuleIssueTypes.get(i))
0097: .setIssueTypeId(v);
0098: }
0099: }
0100:
0101: // update associated MITListItem
0102: if (collMITListItems != null) {
0103: for (int i = 0; i < collMITListItems.size(); i++) {
0104: ((MITListItem) collMITListItems.get(i))
0105: .setIssueTypeId(v);
0106: }
0107: }
0108:
0109: // update associated RModuleAttribute
0110: if (collRModuleAttributes != null) {
0111: for (int i = 0; i < collRModuleAttributes.size(); i++) {
0112: ((RModuleAttribute) collRModuleAttributes.get(i))
0113: .setIssueTypeId(v);
0114: }
0115: }
0116:
0117: // update associated RIssueTypeAttribute
0118: if (collRIssueTypeAttributes != null) {
0119: for (int i = 0; i < collRIssueTypeAttributes.size(); i++) {
0120: ((RIssueTypeAttribute) collRIssueTypeAttributes.get(i))
0121: .setIssueTypeId(v);
0122: }
0123: }
0124:
0125: // update associated RModuleOption
0126: if (collRModuleOptions != null) {
0127: for (int i = 0; i < collRModuleOptions.size(); i++) {
0128: ((RModuleOption) collRModuleOptions.get(i))
0129: .setIssueTypeId(v);
0130: }
0131: }
0132:
0133: // update associated RIssueTypeOption
0134: if (collRIssueTypeOptions != null) {
0135: for (int i = 0; i < collRIssueTypeOptions.size(); i++) {
0136: ((RIssueTypeOption) collRIssueTypeOptions.get(i))
0137: .setIssueTypeId(v);
0138: }
0139: }
0140:
0141: // update associated RModuleUserAttribute
0142: if (collRModuleUserAttributes != null) {
0143: for (int i = 0; i < collRModuleUserAttributes.size(); i++) {
0144: ((RModuleUserAttribute) collRModuleUserAttributes
0145: .get(i)).setIssueTypeId(v);
0146: }
0147: }
0148:
0149: // update associated Query
0150: if (collQuerys != null) {
0151: for (int i = 0; i < collQuerys.size(); i++) {
0152: ((Query) collQuerys.get(i)).setIssueTypeId(v);
0153: }
0154: }
0155:
0156: // update associated Report
0157: if (collReports != null) {
0158: for (int i = 0; i < collReports.size(); i++) {
0159: ((Report) collReports.get(i)).setIssueTypeId(v);
0160: }
0161: }
0162: }
0163:
0164: /**
0165: * Get the Name
0166: *
0167: * @return String
0168: */
0169: public String getName() {
0170: return name;
0171: }
0172:
0173: /**
0174: * Set the value of Name
0175: *
0176: * @param v new value
0177: */
0178: public void setName(String v) {
0179:
0180: if (!ObjectUtils.equals(this .name, v)) {
0181: this .name = v;
0182: setModified(true);
0183: }
0184:
0185: }
0186:
0187: /**
0188: * Get the Description
0189: *
0190: * @return String
0191: */
0192: public String getDescription() {
0193: return description;
0194: }
0195:
0196: /**
0197: * Set the value of Description
0198: *
0199: * @param v new value
0200: */
0201: public void setDescription(String v) {
0202:
0203: if (!ObjectUtils.equals(this .description, v)) {
0204: this .description = v;
0205: setModified(true);
0206: }
0207:
0208: }
0209:
0210: /**
0211: * Get the ParentId
0212: *
0213: * @return Integer
0214: */
0215: public Integer getParentId() {
0216: return parentId;
0217: }
0218:
0219: /**
0220: * Set the value of ParentId
0221: *
0222: * @param v new value
0223: */
0224: public void setParentId(Integer v) throws TorqueException {
0225:
0226: if (!ObjectUtils.equals(this .parentId, v)) {
0227: this .parentId = v;
0228: setModified(true);
0229: }
0230:
0231: if (aIssueTypeRelatedByParentId != null
0232: && !ObjectUtils.equals(aIssueTypeRelatedByParentId
0233: .getIssueTypeId(), v)) {
0234: aIssueTypeRelatedByParentId = null;
0235: }
0236:
0237: }
0238:
0239: /**
0240: * Get the Dedupe
0241: *
0242: * @return boolean
0243: */
0244: public boolean getDedupe() {
0245: return dedupe;
0246: }
0247:
0248: /**
0249: * Set the value of Dedupe
0250: *
0251: * @param v new value
0252: */
0253: public void setDedupe(boolean v) {
0254:
0255: if (this .dedupe != v) {
0256: this .dedupe = v;
0257: setModified(true);
0258: }
0259:
0260: }
0261:
0262: /**
0263: * Get the Deleted
0264: *
0265: * @return boolean
0266: */
0267: public boolean getDeleted() {
0268: return deleted;
0269: }
0270:
0271: /**
0272: * Set the value of Deleted
0273: *
0274: * @param v new value
0275: */
0276: public void setDeleted(boolean v) {
0277:
0278: if (this .deleted != v) {
0279: this .deleted = v;
0280: setModified(true);
0281: }
0282:
0283: }
0284:
0285: /**
0286: * Get the Locked
0287: *
0288: * @return boolean
0289: */
0290: public boolean getLocked() {
0291: return locked;
0292: }
0293:
0294: /**
0295: * Set the value of Locked
0296: *
0297: * @param v new value
0298: */
0299: public void setLocked(boolean v) {
0300:
0301: if (this .locked != v) {
0302: this .locked = v;
0303: setModified(true);
0304: }
0305:
0306: }
0307:
0308: /**
0309: * Get the Isdefault
0310: *
0311: * @return boolean
0312: */
0313: public boolean getIsdefault() {
0314: return isdefault;
0315: }
0316:
0317: /**
0318: * Set the value of Isdefault
0319: *
0320: * @param v new value
0321: */
0322: public void setIsdefault(boolean v) {
0323:
0324: if (this .isdefault != v) {
0325: this .isdefault = v;
0326: setModified(true);
0327: }
0328:
0329: }
0330:
0331: private IssueType aIssueTypeRelatedByParentId;
0332:
0333: /**
0334: * Declares an association between this object and a IssueType object
0335: *
0336: * @param v IssueType
0337: * @throws TorqueException
0338: */
0339: public void setIssueTypeRelatedByParentId(IssueType v)
0340: throws TorqueException {
0341: if (v == null) {
0342: setParentId((Integer) null);
0343: } else {
0344: setParentId(v.getIssueTypeId());
0345: }
0346: aIssueTypeRelatedByParentId = v;
0347: }
0348:
0349: /**
0350: * Returns the associated IssueType object.
0351: * If it was not retrieved before, the object is retrieved from
0352: * the database
0353: *
0354: * @return the associated IssueType object
0355: * @throws TorqueException
0356: */
0357: public IssueType getIssueTypeRelatedByParentId()
0358: throws TorqueException {
0359: if (aIssueTypeRelatedByParentId == null
0360: && (!ObjectUtils.equals(this .parentId, null))) {
0361: aIssueTypeRelatedByParentId = IssueTypeManager
0362: .getInstance(SimpleKey.keyFor(this .parentId));
0363: }
0364: return aIssueTypeRelatedByParentId;
0365: }
0366:
0367: /**
0368: * Return the associated IssueType object
0369: * If it was not retrieved before, the object is retrieved from
0370: * the database using the passed connection
0371: *
0372: * @param connection the connection used to retrieve the associated object
0373: * from the database, if it was not retrieved before
0374: * @return the associated IssueType object
0375: * @throws TorqueException
0376: */
0377: public IssueType getIssueTypeRelatedByParentId(Connection connection)
0378: throws TorqueException {
0379: if (aIssueTypeRelatedByParentId == null
0380: && (!ObjectUtils.equals(this .parentId, null))) {
0381: aIssueTypeRelatedByParentId = IssueTypeManager
0382: .getCachedInstance(SimpleKey.keyFor(this .parentId));
0383: if (aIssueTypeRelatedByParentId == null) {
0384: aIssueTypeRelatedByParentId = IssueTypePeer
0385: .retrieveByPK(SimpleKey.keyFor(this .parentId),
0386: connection);
0387: IssueTypeManager
0388: .putInstance(aIssueTypeRelatedByParentId);
0389: }
0390: }
0391: return aIssueTypeRelatedByParentId;
0392: }
0393:
0394: /**
0395: * Provides convenient way to set a relationship based on a
0396: * ObjectKey, for example
0397: * <code>bar.setFooKey(foo.getPrimaryKey())</code>
0398: *
0399: */
0400: public void setIssueTypeRelatedByParentIdKey(ObjectKey key)
0401: throws TorqueException {
0402:
0403: setParentId(new Integer(((NumberKey) key).intValue()));
0404: }
0405:
0406: /**
0407: * Collection to store aggregation of collAttributeGroups
0408: */
0409: protected List collAttributeGroups;
0410:
0411: /**
0412: * Temporary storage of collAttributeGroups to save a possible db hit in
0413: * the event objects are add to the collection, but the
0414: * complete collection is never requested.
0415: */
0416: protected void initAttributeGroups() {
0417: if (collAttributeGroups == null) {
0418: collAttributeGroups = new ArrayList();
0419: }
0420: }
0421:
0422: /**
0423: * Method called to associate a AttributeGroup object to this object
0424: * through the AttributeGroup foreign key attribute
0425: *
0426: * @param l AttributeGroup
0427: * @throws TorqueException
0428: */
0429: public void addAttributeGroup(AttributeGroup l)
0430: throws TorqueException {
0431: getAttributeGroups().add(l);
0432: l.setIssueType((IssueType) this );
0433: }
0434:
0435: /**
0436: * The criteria used to select the current contents of collAttributeGroups
0437: */
0438: private Criteria lastAttributeGroupsCriteria = null;
0439:
0440: /**
0441: * If this collection has already been initialized, returns
0442: * the collection. Otherwise returns the results of
0443: * getAttributeGroups(new Criteria())
0444: *
0445: * @return the collection of associated objects
0446: * @throws TorqueException
0447: */
0448: public List getAttributeGroups() throws TorqueException {
0449: if (collAttributeGroups == null) {
0450: collAttributeGroups = getAttributeGroups(new Criteria(10));
0451: }
0452: return collAttributeGroups;
0453: }
0454:
0455: /**
0456: * If this collection has already been initialized with
0457: * an identical criteria, it returns the collection.
0458: * Otherwise if this IssueType has previously
0459: * been saved, it will retrieve related AttributeGroups from storage.
0460: * If this IssueType is new, it will return
0461: * an empty collection or the current collection, the criteria
0462: * is ignored on a new object.
0463: *
0464: * @throws TorqueException
0465: */
0466: public List getAttributeGroups(Criteria criteria)
0467: throws TorqueException {
0468: if (collAttributeGroups == null) {
0469: if (isNew()) {
0470: collAttributeGroups = new ArrayList();
0471: } else {
0472: criteria.add(AttributeGroupPeer.ISSUE_TYPE_ID,
0473: getIssueTypeId());
0474: collAttributeGroups = AttributeGroupPeer
0475: .doSelect(criteria);
0476: }
0477: } else {
0478: // criteria has no effect for a new object
0479: if (!isNew()) {
0480: // the following code is to determine if a new query is
0481: // called for. If the criteria is the same as the last
0482: // one, just return the collection.
0483: criteria.add(AttributeGroupPeer.ISSUE_TYPE_ID,
0484: getIssueTypeId());
0485: if (!lastAttributeGroupsCriteria.equals(criteria)) {
0486: collAttributeGroups = AttributeGroupPeer
0487: .doSelect(criteria);
0488: }
0489: }
0490: }
0491: lastAttributeGroupsCriteria = criteria;
0492:
0493: return collAttributeGroups;
0494: }
0495:
0496: /**
0497: * If this collection has already been initialized, returns
0498: * the collection. Otherwise returns the results of
0499: * getAttributeGroups(new Criteria(),Connection)
0500: * This method takes in the Connection also as input so that
0501: * referenced objects can also be obtained using a Connection
0502: * that is taken as input
0503: */
0504: public List getAttributeGroups(Connection con)
0505: throws TorqueException {
0506: if (collAttributeGroups == null) {
0507: collAttributeGroups = getAttributeGroups(new Criteria(10),
0508: con);
0509: }
0510: return collAttributeGroups;
0511: }
0512:
0513: /**
0514: * If this collection has already been initialized with
0515: * an identical criteria, it returns the collection.
0516: * Otherwise if this IssueType has previously
0517: * been saved, it will retrieve related AttributeGroups from storage.
0518: * If this IssueType is new, it will return
0519: * an empty collection or the current collection, the criteria
0520: * is ignored on a new object.
0521: * This method takes in the Connection also as input so that
0522: * referenced objects can also be obtained using a Connection
0523: * that is taken as input
0524: */
0525: public List getAttributeGroups(Criteria criteria, Connection con)
0526: throws TorqueException {
0527: if (collAttributeGroups == null) {
0528: if (isNew()) {
0529: collAttributeGroups = new ArrayList();
0530: } else {
0531: criteria.add(AttributeGroupPeer.ISSUE_TYPE_ID,
0532: getIssueTypeId());
0533: collAttributeGroups = AttributeGroupPeer.doSelect(
0534: criteria, con);
0535: }
0536: } else {
0537: // criteria has no effect for a new object
0538: if (!isNew()) {
0539: // the following code is to determine if a new query is
0540: // called for. If the criteria is the same as the last
0541: // one, just return the collection.
0542: criteria.add(AttributeGroupPeer.ISSUE_TYPE_ID,
0543: getIssueTypeId());
0544: if (!lastAttributeGroupsCriteria.equals(criteria)) {
0545: collAttributeGroups = AttributeGroupPeer.doSelect(
0546: criteria, con);
0547: }
0548: }
0549: }
0550: lastAttributeGroupsCriteria = criteria;
0551:
0552: return collAttributeGroups;
0553: }
0554:
0555: /**
0556: * If this collection has already been initialized with
0557: * an identical criteria, it returns the collection.
0558: * Otherwise if this IssueType is new, it will return
0559: * an empty collection; or if this IssueType has previously
0560: * been saved, it will retrieve related AttributeGroups from storage.
0561: *
0562: * This method is protected by default in order to keep the public
0563: * api reasonable. You can provide public methods for those you
0564: * actually need in IssueType.
0565: */
0566: protected List getAttributeGroupsJoinScarabModule(Criteria criteria)
0567: throws TorqueException {
0568: if (collAttributeGroups == null) {
0569: if (isNew()) {
0570: collAttributeGroups = new ArrayList();
0571: } else {
0572: criteria.add(AttributeGroupPeer.ISSUE_TYPE_ID,
0573: getIssueTypeId());
0574: collAttributeGroups = AttributeGroupPeer
0575: .doSelectJoinScarabModule(criteria);
0576: }
0577: } else {
0578: // the following code is to determine if a new query is
0579: // called for. If the criteria is the same as the last
0580: // one, just return the collection.
0581: criteria.add(AttributeGroupPeer.ISSUE_TYPE_ID,
0582: getIssueTypeId());
0583: if (!lastAttributeGroupsCriteria.equals(criteria)) {
0584: collAttributeGroups = AttributeGroupPeer
0585: .doSelectJoinScarabModule(criteria);
0586: }
0587: }
0588: lastAttributeGroupsCriteria = criteria;
0589:
0590: return collAttributeGroups;
0591: }
0592:
0593: /**
0594: * If this collection has already been initialized with
0595: * an identical criteria, it returns the collection.
0596: * Otherwise if this IssueType is new, it will return
0597: * an empty collection; or if this IssueType has previously
0598: * been saved, it will retrieve related AttributeGroups from storage.
0599: *
0600: * This method is protected by default in order to keep the public
0601: * api reasonable. You can provide public methods for those you
0602: * actually need in IssueType.
0603: */
0604: protected List getAttributeGroupsJoinIssueType(Criteria criteria)
0605: throws TorqueException {
0606: if (collAttributeGroups == null) {
0607: if (isNew()) {
0608: collAttributeGroups = new ArrayList();
0609: } else {
0610: criteria.add(AttributeGroupPeer.ISSUE_TYPE_ID,
0611: getIssueTypeId());
0612: collAttributeGroups = AttributeGroupPeer
0613: .doSelectJoinIssueType(criteria);
0614: }
0615: } else {
0616: // the following code is to determine if a new query is
0617: // called for. If the criteria is the same as the last
0618: // one, just return the collection.
0619: criteria.add(AttributeGroupPeer.ISSUE_TYPE_ID,
0620: getIssueTypeId());
0621: if (!lastAttributeGroupsCriteria.equals(criteria)) {
0622: collAttributeGroups = AttributeGroupPeer
0623: .doSelectJoinIssueType(criteria);
0624: }
0625: }
0626: lastAttributeGroupsCriteria = criteria;
0627:
0628: return collAttributeGroups;
0629: }
0630:
0631: /**
0632: * Collection to store aggregation of collIssues
0633: */
0634: protected List collIssues;
0635:
0636: /**
0637: * Temporary storage of collIssues to save a possible db hit in
0638: * the event objects are add to the collection, but the
0639: * complete collection is never requested.
0640: */
0641: protected void initIssues() {
0642: if (collIssues == null) {
0643: collIssues = new ArrayList();
0644: }
0645: }
0646:
0647: /**
0648: * Method called to associate a Issue object to this object
0649: * through the Issue foreign key attribute
0650: *
0651: * @param l Issue
0652: * @throws TorqueException
0653: */
0654: public void addIssue(Issue l) throws TorqueException {
0655: getIssues().add(l);
0656: l.setIssueType((IssueType) this );
0657: }
0658:
0659: /**
0660: * The criteria used to select the current contents of collIssues
0661: */
0662: private Criteria lastIssuesCriteria = null;
0663:
0664: /**
0665: * If this collection has already been initialized, returns
0666: * the collection. Otherwise returns the results of
0667: * getIssues(new Criteria())
0668: *
0669: * @return the collection of associated objects
0670: * @throws TorqueException
0671: */
0672: public List getIssues() throws TorqueException {
0673: if (collIssues == null) {
0674: collIssues = getIssues(new Criteria(10));
0675: }
0676: return collIssues;
0677: }
0678:
0679: /**
0680: * If this collection has already been initialized with
0681: * an identical criteria, it returns the collection.
0682: * Otherwise if this IssueType has previously
0683: * been saved, it will retrieve related Issues from storage.
0684: * If this IssueType is new, it will return
0685: * an empty collection or the current collection, the criteria
0686: * is ignored on a new object.
0687: *
0688: * @throws TorqueException
0689: */
0690: public List getIssues(Criteria criteria) throws TorqueException {
0691: if (collIssues == null) {
0692: if (isNew()) {
0693: collIssues = new ArrayList();
0694: } else {
0695: criteria.add(IssuePeer.TYPE_ID, getIssueTypeId());
0696: collIssues = IssuePeer.doSelect(criteria);
0697: }
0698: } else {
0699: // criteria has no effect for a new object
0700: if (!isNew()) {
0701: // the following code is to determine if a new query is
0702: // called for. If the criteria is the same as the last
0703: // one, just return the collection.
0704: criteria.add(IssuePeer.TYPE_ID, getIssueTypeId());
0705: if (!lastIssuesCriteria.equals(criteria)) {
0706: collIssues = IssuePeer.doSelect(criteria);
0707: }
0708: }
0709: }
0710: lastIssuesCriteria = criteria;
0711:
0712: return collIssues;
0713: }
0714:
0715: /**
0716: * If this collection has already been initialized, returns
0717: * the collection. Otherwise returns the results of
0718: * getIssues(new Criteria(),Connection)
0719: * This method takes in the Connection also as input so that
0720: * referenced objects can also be obtained using a Connection
0721: * that is taken as input
0722: */
0723: public List getIssues(Connection con) throws TorqueException {
0724: if (collIssues == null) {
0725: collIssues = getIssues(new Criteria(10), con);
0726: }
0727: return collIssues;
0728: }
0729:
0730: /**
0731: * If this collection has already been initialized with
0732: * an identical criteria, it returns the collection.
0733: * Otherwise if this IssueType has previously
0734: * been saved, it will retrieve related Issues from storage.
0735: * If this IssueType is new, it will return
0736: * an empty collection or the current collection, the criteria
0737: * is ignored on a new object.
0738: * This method takes in the Connection also as input so that
0739: * referenced objects can also be obtained using a Connection
0740: * that is taken as input
0741: */
0742: public List getIssues(Criteria criteria, Connection con)
0743: throws TorqueException {
0744: if (collIssues == null) {
0745: if (isNew()) {
0746: collIssues = new ArrayList();
0747: } else {
0748: criteria.add(IssuePeer.TYPE_ID, getIssueTypeId());
0749: collIssues = IssuePeer.doSelect(criteria, con);
0750: }
0751: } else {
0752: // criteria has no effect for a new object
0753: if (!isNew()) {
0754: // the following code is to determine if a new query is
0755: // called for. If the criteria is the same as the last
0756: // one, just return the collection.
0757: criteria.add(IssuePeer.TYPE_ID, getIssueTypeId());
0758: if (!lastIssuesCriteria.equals(criteria)) {
0759: collIssues = IssuePeer.doSelect(criteria, con);
0760: }
0761: }
0762: }
0763: lastIssuesCriteria = criteria;
0764:
0765: return collIssues;
0766: }
0767:
0768: /**
0769: * If this collection has already been initialized with
0770: * an identical criteria, it returns the collection.
0771: * Otherwise if this IssueType is new, it will return
0772: * an empty collection; or if this IssueType has previously
0773: * been saved, it will retrieve related Issues from storage.
0774: *
0775: * This method is protected by default in order to keep the public
0776: * api reasonable. You can provide public methods for those you
0777: * actually need in IssueType.
0778: */
0779: protected List getIssuesJoinScarabModule(Criteria criteria)
0780: throws TorqueException {
0781: if (collIssues == null) {
0782: if (isNew()) {
0783: collIssues = new ArrayList();
0784: } else {
0785: criteria.add(IssuePeer.TYPE_ID, getIssueTypeId());
0786: collIssues = IssuePeer
0787: .doSelectJoinScarabModule(criteria);
0788: }
0789: } else {
0790: // the following code is to determine if a new query is
0791: // called for. If the criteria is the same as the last
0792: // one, just return the collection.
0793: criteria.add(IssuePeer.TYPE_ID, getIssueTypeId());
0794: if (!lastIssuesCriteria.equals(criteria)) {
0795: collIssues = IssuePeer
0796: .doSelectJoinScarabModule(criteria);
0797: }
0798: }
0799: lastIssuesCriteria = criteria;
0800:
0801: return collIssues;
0802: }
0803:
0804: /**
0805: * If this collection has already been initialized with
0806: * an identical criteria, it returns the collection.
0807: * Otherwise if this IssueType is new, it will return
0808: * an empty collection; or if this IssueType has previously
0809: * been saved, it will retrieve related Issues from storage.
0810: *
0811: * This method is protected by default in order to keep the public
0812: * api reasonable. You can provide public methods for those you
0813: * actually need in IssueType.
0814: */
0815: protected List getIssuesJoinIssueType(Criteria criteria)
0816: throws TorqueException {
0817: if (collIssues == null) {
0818: if (isNew()) {
0819: collIssues = new ArrayList();
0820: } else {
0821: criteria.add(IssuePeer.TYPE_ID, getIssueTypeId());
0822: collIssues = IssuePeer.doSelectJoinIssueType(criteria);
0823: }
0824: } else {
0825: // the following code is to determine if a new query is
0826: // called for. If the criteria is the same as the last
0827: // one, just return the collection.
0828: criteria.add(IssuePeer.TYPE_ID, getIssueTypeId());
0829: if (!lastIssuesCriteria.equals(criteria)) {
0830: collIssues = IssuePeer.doSelectJoinIssueType(criteria);
0831: }
0832: }
0833: lastIssuesCriteria = criteria;
0834:
0835: return collIssues;
0836: }
0837:
0838: /**
0839: * If this collection has already been initialized with
0840: * an identical criteria, it returns the collection.
0841: * Otherwise if this IssueType is new, it will return
0842: * an empty collection; or if this IssueType has previously
0843: * been saved, it will retrieve related Issues from storage.
0844: *
0845: * This method is protected by default in order to keep the public
0846: * api reasonable. You can provide public methods for those you
0847: * actually need in IssueType.
0848: */
0849: protected List getIssuesJoinActivitySetRelatedByCreatedTransId(
0850: Criteria criteria) throws TorqueException {
0851: if (collIssues == null) {
0852: if (isNew()) {
0853: collIssues = new ArrayList();
0854: } else {
0855: criteria.add(IssuePeer.TYPE_ID, getIssueTypeId());
0856: collIssues = IssuePeer
0857: .doSelectJoinActivitySetRelatedByCreatedTransId(criteria);
0858: }
0859: } else {
0860: // the following code is to determine if a new query is
0861: // called for. If the criteria is the same as the last
0862: // one, just return the collection.
0863: criteria.add(IssuePeer.TYPE_ID, getIssueTypeId());
0864: if (!lastIssuesCriteria.equals(criteria)) {
0865: collIssues = IssuePeer
0866: .doSelectJoinActivitySetRelatedByCreatedTransId(criteria);
0867: }
0868: }
0869: lastIssuesCriteria = criteria;
0870:
0871: return collIssues;
0872: }
0873:
0874: /**
0875: * If this collection has already been initialized with
0876: * an identical criteria, it returns the collection.
0877: * Otherwise if this IssueType is new, it will return
0878: * an empty collection; or if this IssueType has previously
0879: * been saved, it will retrieve related Issues from storage.
0880: *
0881: * This method is protected by default in order to keep the public
0882: * api reasonable. You can provide public methods for those you
0883: * actually need in IssueType.
0884: */
0885: protected List getIssuesJoinActivitySetRelatedByLastTransId(
0886: Criteria criteria) throws TorqueException {
0887: if (collIssues == null) {
0888: if (isNew()) {
0889: collIssues = new ArrayList();
0890: } else {
0891: criteria.add(IssuePeer.TYPE_ID, getIssueTypeId());
0892: collIssues = IssuePeer
0893: .doSelectJoinActivitySetRelatedByLastTransId(criteria);
0894: }
0895: } else {
0896: // the following code is to determine if a new query is
0897: // called for. If the criteria is the same as the last
0898: // one, just return the collection.
0899: criteria.add(IssuePeer.TYPE_ID, getIssueTypeId());
0900: if (!lastIssuesCriteria.equals(criteria)) {
0901: collIssues = IssuePeer
0902: .doSelectJoinActivitySetRelatedByLastTransId(criteria);
0903: }
0904: }
0905: lastIssuesCriteria = criteria;
0906:
0907: return collIssues;
0908: }
0909:
0910: /**
0911: * Collection to store aggregation of collRModuleIssueTypes
0912: */
0913: protected List collRModuleIssueTypes;
0914:
0915: /**
0916: * Temporary storage of collRModuleIssueTypes to save a possible db hit in
0917: * the event objects are add to the collection, but the
0918: * complete collection is never requested.
0919: */
0920: protected void initRModuleIssueTypes() {
0921: if (collRModuleIssueTypes == null) {
0922: collRModuleIssueTypes = new ArrayList();
0923: }
0924: }
0925:
0926: /**
0927: * Method called to associate a RModuleIssueType object to this object
0928: * through the RModuleIssueType foreign key attribute
0929: *
0930: * @param l RModuleIssueType
0931: * @throws TorqueException
0932: */
0933: public void addRModuleIssueType(RModuleIssueType l)
0934: throws TorqueException {
0935: getRModuleIssueTypes().add(l);
0936: l.setIssueType((IssueType) this );
0937: }
0938:
0939: /**
0940: * The criteria used to select the current contents of collRModuleIssueTypes
0941: */
0942: private Criteria lastRModuleIssueTypesCriteria = null;
0943:
0944: /**
0945: * If this collection has already been initialized, returns
0946: * the collection. Otherwise returns the results of
0947: * getRModuleIssueTypes(new Criteria())
0948: *
0949: * @return the collection of associated objects
0950: * @throws TorqueException
0951: */
0952: public List getRModuleIssueTypes() throws TorqueException {
0953: if (collRModuleIssueTypes == null) {
0954: collRModuleIssueTypes = getRModuleIssueTypes(new Criteria(
0955: 10));
0956: }
0957: return collRModuleIssueTypes;
0958: }
0959:
0960: /**
0961: * If this collection has already been initialized with
0962: * an identical criteria, it returns the collection.
0963: * Otherwise if this IssueType has previously
0964: * been saved, it will retrieve related RModuleIssueTypes from storage.
0965: * If this IssueType is new, it will return
0966: * an empty collection or the current collection, the criteria
0967: * is ignored on a new object.
0968: *
0969: * @throws TorqueException
0970: */
0971: public List getRModuleIssueTypes(Criteria criteria)
0972: throws TorqueException {
0973: if (collRModuleIssueTypes == null) {
0974: if (isNew()) {
0975: collRModuleIssueTypes = new ArrayList();
0976: } else {
0977: criteria.add(RModuleIssueTypePeer.ISSUE_TYPE_ID,
0978: getIssueTypeId());
0979: collRModuleIssueTypes = RModuleIssueTypePeer
0980: .doSelect(criteria);
0981: }
0982: } else {
0983: // criteria has no effect for a new object
0984: if (!isNew()) {
0985: // the following code is to determine if a new query is
0986: // called for. If the criteria is the same as the last
0987: // one, just return the collection.
0988: criteria.add(RModuleIssueTypePeer.ISSUE_TYPE_ID,
0989: getIssueTypeId());
0990: if (!lastRModuleIssueTypesCriteria.equals(criteria)) {
0991: collRModuleIssueTypes = RModuleIssueTypePeer
0992: .doSelect(criteria);
0993: }
0994: }
0995: }
0996: lastRModuleIssueTypesCriteria = criteria;
0997:
0998: return collRModuleIssueTypes;
0999: }
1000:
1001: /**
1002: * If this collection has already been initialized, returns
1003: * the collection. Otherwise returns the results of
1004: * getRModuleIssueTypes(new Criteria(),Connection)
1005: * This method takes in the Connection also as input so that
1006: * referenced objects can also be obtained using a Connection
1007: * that is taken as input
1008: */
1009: public List getRModuleIssueTypes(Connection con)
1010: throws TorqueException {
1011: if (collRModuleIssueTypes == null) {
1012: collRModuleIssueTypes = getRModuleIssueTypes(new Criteria(
1013: 10), con);
1014: }
1015: return collRModuleIssueTypes;
1016: }
1017:
1018: /**
1019: * If this collection has already been initialized with
1020: * an identical criteria, it returns the collection.
1021: * Otherwise if this IssueType has previously
1022: * been saved, it will retrieve related RModuleIssueTypes from storage.
1023: * If this IssueType is new, it will return
1024: * an empty collection or the current collection, the criteria
1025: * is ignored on a new object.
1026: * This method takes in the Connection also as input so that
1027: * referenced objects can also be obtained using a Connection
1028: * that is taken as input
1029: */
1030: public List getRModuleIssueTypes(Criteria criteria, Connection con)
1031: throws TorqueException {
1032: if (collRModuleIssueTypes == null) {
1033: if (isNew()) {
1034: collRModuleIssueTypes = new ArrayList();
1035: } else {
1036: criteria.add(RModuleIssueTypePeer.ISSUE_TYPE_ID,
1037: getIssueTypeId());
1038: collRModuleIssueTypes = RModuleIssueTypePeer.doSelect(
1039: criteria, con);
1040: }
1041: } else {
1042: // criteria has no effect for a new object
1043: if (!isNew()) {
1044: // the following code is to determine if a new query is
1045: // called for. If the criteria is the same as the last
1046: // one, just return the collection.
1047: criteria.add(RModuleIssueTypePeer.ISSUE_TYPE_ID,
1048: getIssueTypeId());
1049: if (!lastRModuleIssueTypesCriteria.equals(criteria)) {
1050: collRModuleIssueTypes = RModuleIssueTypePeer
1051: .doSelect(criteria, con);
1052: }
1053: }
1054: }
1055: lastRModuleIssueTypesCriteria = criteria;
1056:
1057: return collRModuleIssueTypes;
1058: }
1059:
1060: /**
1061: * If this collection has already been initialized with
1062: * an identical criteria, it returns the collection.
1063: * Otherwise if this IssueType is new, it will return
1064: * an empty collection; or if this IssueType has previously
1065: * been saved, it will retrieve related RModuleIssueTypes from storage.
1066: *
1067: * This method is protected by default in order to keep the public
1068: * api reasonable. You can provide public methods for those you
1069: * actually need in IssueType.
1070: */
1071: protected List getRModuleIssueTypesJoinScarabModule(
1072: Criteria criteria) throws TorqueException {
1073: if (collRModuleIssueTypes == null) {
1074: if (isNew()) {
1075: collRModuleIssueTypes = new ArrayList();
1076: } else {
1077: criteria.add(RModuleIssueTypePeer.ISSUE_TYPE_ID,
1078: getIssueTypeId());
1079: collRModuleIssueTypes = RModuleIssueTypePeer
1080: .doSelectJoinScarabModule(criteria);
1081: }
1082: } else {
1083: // the following code is to determine if a new query is
1084: // called for. If the criteria is the same as the last
1085: // one, just return the collection.
1086: criteria.add(RModuleIssueTypePeer.ISSUE_TYPE_ID,
1087: getIssueTypeId());
1088: if (!lastRModuleIssueTypesCriteria.equals(criteria)) {
1089: collRModuleIssueTypes = RModuleIssueTypePeer
1090: .doSelectJoinScarabModule(criteria);
1091: }
1092: }
1093: lastRModuleIssueTypesCriteria = criteria;
1094:
1095: return collRModuleIssueTypes;
1096: }
1097:
1098: /**
1099: * If this collection has already been initialized with
1100: * an identical criteria, it returns the collection.
1101: * Otherwise if this IssueType is new, it will return
1102: * an empty collection; or if this IssueType has previously
1103: * been saved, it will retrieve related RModuleIssueTypes from storage.
1104: *
1105: * This method is protected by default in order to keep the public
1106: * api reasonable. You can provide public methods for those you
1107: * actually need in IssueType.
1108: */
1109: protected List getRModuleIssueTypesJoinIssueType(Criteria criteria)
1110: throws TorqueException {
1111: if (collRModuleIssueTypes == null) {
1112: if (isNew()) {
1113: collRModuleIssueTypes = new ArrayList();
1114: } else {
1115: criteria.add(RModuleIssueTypePeer.ISSUE_TYPE_ID,
1116: getIssueTypeId());
1117: collRModuleIssueTypes = RModuleIssueTypePeer
1118: .doSelectJoinIssueType(criteria);
1119: }
1120: } else {
1121: // the following code is to determine if a new query is
1122: // called for. If the criteria is the same as the last
1123: // one, just return the collection.
1124: criteria.add(RModuleIssueTypePeer.ISSUE_TYPE_ID,
1125: getIssueTypeId());
1126: if (!lastRModuleIssueTypesCriteria.equals(criteria)) {
1127: collRModuleIssueTypes = RModuleIssueTypePeer
1128: .doSelectJoinIssueType(criteria);
1129: }
1130: }
1131: lastRModuleIssueTypesCriteria = criteria;
1132:
1133: return collRModuleIssueTypes;
1134: }
1135:
1136: /**
1137: * Collection to store aggregation of collMITListItems
1138: */
1139: protected List collMITListItems;
1140:
1141: /**
1142: * Temporary storage of collMITListItems to save a possible db hit in
1143: * the event objects are add to the collection, but the
1144: * complete collection is never requested.
1145: */
1146: protected void initMITListItems() {
1147: if (collMITListItems == null) {
1148: collMITListItems = new ArrayList();
1149: }
1150: }
1151:
1152: /**
1153: * Method called to associate a MITListItem object to this object
1154: * through the MITListItem foreign key attribute
1155: *
1156: * @param l MITListItem
1157: * @throws TorqueException
1158: */
1159: public void addMITListItem(MITListItem l) throws TorqueException {
1160: getMITListItems().add(l);
1161: l.setIssueType((IssueType) this );
1162: }
1163:
1164: /**
1165: * The criteria used to select the current contents of collMITListItems
1166: */
1167: private Criteria lastMITListItemsCriteria = null;
1168:
1169: /**
1170: * If this collection has already been initialized, returns
1171: * the collection. Otherwise returns the results of
1172: * getMITListItems(new Criteria())
1173: *
1174: * @return the collection of associated objects
1175: * @throws TorqueException
1176: */
1177: public List getMITListItems() throws TorqueException {
1178: if (collMITListItems == null) {
1179: collMITListItems = getMITListItems(new Criteria(10));
1180: }
1181: return collMITListItems;
1182: }
1183:
1184: /**
1185: * If this collection has already been initialized with
1186: * an identical criteria, it returns the collection.
1187: * Otherwise if this IssueType has previously
1188: * been saved, it will retrieve related MITListItems from storage.
1189: * If this IssueType is new, it will return
1190: * an empty collection or the current collection, the criteria
1191: * is ignored on a new object.
1192: *
1193: * @throws TorqueException
1194: */
1195: public List getMITListItems(Criteria criteria)
1196: throws TorqueException {
1197: if (collMITListItems == null) {
1198: if (isNew()) {
1199: collMITListItems = new ArrayList();
1200: } else {
1201: criteria.add(MITListItemPeer.ISSUE_TYPE_ID,
1202: getIssueTypeId());
1203: collMITListItems = MITListItemPeer.doSelect(criteria);
1204: }
1205: } else {
1206: // criteria has no effect for a new object
1207: if (!isNew()) {
1208: // the following code is to determine if a new query is
1209: // called for. If the criteria is the same as the last
1210: // one, just return the collection.
1211: criteria.add(MITListItemPeer.ISSUE_TYPE_ID,
1212: getIssueTypeId());
1213: if (!lastMITListItemsCriteria.equals(criteria)) {
1214: collMITListItems = MITListItemPeer
1215: .doSelect(criteria);
1216: }
1217: }
1218: }
1219: lastMITListItemsCriteria = criteria;
1220:
1221: return collMITListItems;
1222: }
1223:
1224: /**
1225: * If this collection has already been initialized, returns
1226: * the collection. Otherwise returns the results of
1227: * getMITListItems(new Criteria(),Connection)
1228: * This method takes in the Connection also as input so that
1229: * referenced objects can also be obtained using a Connection
1230: * that is taken as input
1231: */
1232: public List getMITListItems(Connection con) throws TorqueException {
1233: if (collMITListItems == null) {
1234: collMITListItems = getMITListItems(new Criteria(10), con);
1235: }
1236: return collMITListItems;
1237: }
1238:
1239: /**
1240: * If this collection has already been initialized with
1241: * an identical criteria, it returns the collection.
1242: * Otherwise if this IssueType has previously
1243: * been saved, it will retrieve related MITListItems from storage.
1244: * If this IssueType is new, it will return
1245: * an empty collection or the current collection, the criteria
1246: * is ignored on a new object.
1247: * This method takes in the Connection also as input so that
1248: * referenced objects can also be obtained using a Connection
1249: * that is taken as input
1250: */
1251: public List getMITListItems(Criteria criteria, Connection con)
1252: throws TorqueException {
1253: if (collMITListItems == null) {
1254: if (isNew()) {
1255: collMITListItems = new ArrayList();
1256: } else {
1257: criteria.add(MITListItemPeer.ISSUE_TYPE_ID,
1258: getIssueTypeId());
1259: collMITListItems = MITListItemPeer.doSelect(criteria,
1260: con);
1261: }
1262: } else {
1263: // criteria has no effect for a new object
1264: if (!isNew()) {
1265: // the following code is to determine if a new query is
1266: // called for. If the criteria is the same as the last
1267: // one, just return the collection.
1268: criteria.add(MITListItemPeer.ISSUE_TYPE_ID,
1269: getIssueTypeId());
1270: if (!lastMITListItemsCriteria.equals(criteria)) {
1271: collMITListItems = MITListItemPeer.doSelect(
1272: criteria, con);
1273: }
1274: }
1275: }
1276: lastMITListItemsCriteria = criteria;
1277:
1278: return collMITListItems;
1279: }
1280:
1281: /**
1282: * If this collection has already been initialized with
1283: * an identical criteria, it returns the collection.
1284: * Otherwise if this IssueType is new, it will return
1285: * an empty collection; or if this IssueType has previously
1286: * been saved, it will retrieve related MITListItems from storage.
1287: *
1288: * This method is protected by default in order to keep the public
1289: * api reasonable. You can provide public methods for those you
1290: * actually need in IssueType.
1291: */
1292: protected List getMITListItemsJoinMITList(Criteria criteria)
1293: throws TorqueException {
1294: if (collMITListItems == null) {
1295: if (isNew()) {
1296: collMITListItems = new ArrayList();
1297: } else {
1298: criteria.add(MITListItemPeer.ISSUE_TYPE_ID,
1299: getIssueTypeId());
1300: collMITListItems = MITListItemPeer
1301: .doSelectJoinMITList(criteria);
1302: }
1303: } else {
1304: // the following code is to determine if a new query is
1305: // called for. If the criteria is the same as the last
1306: // one, just return the collection.
1307: criteria.add(MITListItemPeer.ISSUE_TYPE_ID,
1308: getIssueTypeId());
1309: if (!lastMITListItemsCriteria.equals(criteria)) {
1310: collMITListItems = MITListItemPeer
1311: .doSelectJoinMITList(criteria);
1312: }
1313: }
1314: lastMITListItemsCriteria = criteria;
1315:
1316: return collMITListItems;
1317: }
1318:
1319: /**
1320: * If this collection has already been initialized with
1321: * an identical criteria, it returns the collection.
1322: * Otherwise if this IssueType is new, it will return
1323: * an empty collection; or if this IssueType has previously
1324: * been saved, it will retrieve related MITListItems from storage.
1325: *
1326: * This method is protected by default in order to keep the public
1327: * api reasonable. You can provide public methods for those you
1328: * actually need in IssueType.
1329: */
1330: protected List getMITListItemsJoinScarabModule(Criteria criteria)
1331: throws TorqueException {
1332: if (collMITListItems == null) {
1333: if (isNew()) {
1334: collMITListItems = new ArrayList();
1335: } else {
1336: criteria.add(MITListItemPeer.ISSUE_TYPE_ID,
1337: getIssueTypeId());
1338: collMITListItems = MITListItemPeer
1339: .doSelectJoinScarabModule(criteria);
1340: }
1341: } else {
1342: // the following code is to determine if a new query is
1343: // called for. If the criteria is the same as the last
1344: // one, just return the collection.
1345: criteria.add(MITListItemPeer.ISSUE_TYPE_ID,
1346: getIssueTypeId());
1347: if (!lastMITListItemsCriteria.equals(criteria)) {
1348: collMITListItems = MITListItemPeer
1349: .doSelectJoinScarabModule(criteria);
1350: }
1351: }
1352: lastMITListItemsCriteria = criteria;
1353:
1354: return collMITListItems;
1355: }
1356:
1357: /**
1358: * If this collection has already been initialized with
1359: * an identical criteria, it returns the collection.
1360: * Otherwise if this IssueType is new, it will return
1361: * an empty collection; or if this IssueType has previously
1362: * been saved, it will retrieve related MITListItems from storage.
1363: *
1364: * This method is protected by default in order to keep the public
1365: * api reasonable. You can provide public methods for those you
1366: * actually need in IssueType.
1367: */
1368: protected List getMITListItemsJoinIssueType(Criteria criteria)
1369: throws TorqueException {
1370: if (collMITListItems == null) {
1371: if (isNew()) {
1372: collMITListItems = new ArrayList();
1373: } else {
1374: criteria.add(MITListItemPeer.ISSUE_TYPE_ID,
1375: getIssueTypeId());
1376: collMITListItems = MITListItemPeer
1377: .doSelectJoinIssueType(criteria);
1378: }
1379: } else {
1380: // the following code is to determine if a new query is
1381: // called for. If the criteria is the same as the last
1382: // one, just return the collection.
1383: criteria.add(MITListItemPeer.ISSUE_TYPE_ID,
1384: getIssueTypeId());
1385: if (!lastMITListItemsCriteria.equals(criteria)) {
1386: collMITListItems = MITListItemPeer
1387: .doSelectJoinIssueType(criteria);
1388: }
1389: }
1390: lastMITListItemsCriteria = criteria;
1391:
1392: return collMITListItems;
1393: }
1394:
1395: /**
1396: * Collection to store aggregation of collRModuleAttributes
1397: */
1398: protected List collRModuleAttributes;
1399:
1400: /**
1401: * Temporary storage of collRModuleAttributes to save a possible db hit in
1402: * the event objects are add to the collection, but the
1403: * complete collection is never requested.
1404: */
1405: protected void initRModuleAttributes() {
1406: if (collRModuleAttributes == null) {
1407: collRModuleAttributes = new ArrayList();
1408: }
1409: }
1410:
1411: /**
1412: * Method called to associate a RModuleAttribute object to this object
1413: * through the RModuleAttribute foreign key attribute
1414: *
1415: * @param l RModuleAttribute
1416: * @throws TorqueException
1417: */
1418: public void addRModuleAttribute(RModuleAttribute l)
1419: throws TorqueException {
1420: getRModuleAttributes().add(l);
1421: l.setIssueType((IssueType) this );
1422: }
1423:
1424: /**
1425: * The criteria used to select the current contents of collRModuleAttributes
1426: */
1427: private Criteria lastRModuleAttributesCriteria = null;
1428:
1429: /**
1430: * If this collection has already been initialized, returns
1431: * the collection. Otherwise returns the results of
1432: * getRModuleAttributes(new Criteria())
1433: *
1434: * @return the collection of associated objects
1435: * @throws TorqueException
1436: */
1437: public List getRModuleAttributes() throws TorqueException {
1438: if (collRModuleAttributes == null) {
1439: collRModuleAttributes = getRModuleAttributes(new Criteria(
1440: 10));
1441: }
1442: return collRModuleAttributes;
1443: }
1444:
1445: /**
1446: * If this collection has already been initialized with
1447: * an identical criteria, it returns the collection.
1448: * Otherwise if this IssueType has previously
1449: * been saved, it will retrieve related RModuleAttributes from storage.
1450: * If this IssueType is new, it will return
1451: * an empty collection or the current collection, the criteria
1452: * is ignored on a new object.
1453: *
1454: * @throws TorqueException
1455: */
1456: public List getRModuleAttributes(Criteria criteria)
1457: throws TorqueException {
1458: if (collRModuleAttributes == null) {
1459: if (isNew()) {
1460: collRModuleAttributes = new ArrayList();
1461: } else {
1462: criteria.add(RModuleAttributePeer.ISSUE_TYPE_ID,
1463: getIssueTypeId());
1464: collRModuleAttributes = RModuleAttributePeer
1465: .doSelect(criteria);
1466: }
1467: } else {
1468: // criteria has no effect for a new object
1469: if (!isNew()) {
1470: // the following code is to determine if a new query is
1471: // called for. If the criteria is the same as the last
1472: // one, just return the collection.
1473: criteria.add(RModuleAttributePeer.ISSUE_TYPE_ID,
1474: getIssueTypeId());
1475: if (!lastRModuleAttributesCriteria.equals(criteria)) {
1476: collRModuleAttributes = RModuleAttributePeer
1477: .doSelect(criteria);
1478: }
1479: }
1480: }
1481: lastRModuleAttributesCriteria = criteria;
1482:
1483: return collRModuleAttributes;
1484: }
1485:
1486: /**
1487: * If this collection has already been initialized, returns
1488: * the collection. Otherwise returns the results of
1489: * getRModuleAttributes(new Criteria(),Connection)
1490: * This method takes in the Connection also as input so that
1491: * referenced objects can also be obtained using a Connection
1492: * that is taken as input
1493: */
1494: public List getRModuleAttributes(Connection con)
1495: throws TorqueException {
1496: if (collRModuleAttributes == null) {
1497: collRModuleAttributes = getRModuleAttributes(new Criteria(
1498: 10), con);
1499: }
1500: return collRModuleAttributes;
1501: }
1502:
1503: /**
1504: * If this collection has already been initialized with
1505: * an identical criteria, it returns the collection.
1506: * Otherwise if this IssueType has previously
1507: * been saved, it will retrieve related RModuleAttributes from storage.
1508: * If this IssueType is new, it will return
1509: * an empty collection or the current collection, the criteria
1510: * is ignored on a new object.
1511: * This method takes in the Connection also as input so that
1512: * referenced objects can also be obtained using a Connection
1513: * that is taken as input
1514: */
1515: public List getRModuleAttributes(Criteria criteria, Connection con)
1516: throws TorqueException {
1517: if (collRModuleAttributes == null) {
1518: if (isNew()) {
1519: collRModuleAttributes = new ArrayList();
1520: } else {
1521: criteria.add(RModuleAttributePeer.ISSUE_TYPE_ID,
1522: getIssueTypeId());
1523: collRModuleAttributes = RModuleAttributePeer.doSelect(
1524: criteria, con);
1525: }
1526: } else {
1527: // criteria has no effect for a new object
1528: if (!isNew()) {
1529: // the following code is to determine if a new query is
1530: // called for. If the criteria is the same as the last
1531: // one, just return the collection.
1532: criteria.add(RModuleAttributePeer.ISSUE_TYPE_ID,
1533: getIssueTypeId());
1534: if (!lastRModuleAttributesCriteria.equals(criteria)) {
1535: collRModuleAttributes = RModuleAttributePeer
1536: .doSelect(criteria, con);
1537: }
1538: }
1539: }
1540: lastRModuleAttributesCriteria = criteria;
1541:
1542: return collRModuleAttributes;
1543: }
1544:
1545: /**
1546: * If this collection has already been initialized with
1547: * an identical criteria, it returns the collection.
1548: * Otherwise if this IssueType is new, it will return
1549: * an empty collection; or if this IssueType has previously
1550: * been saved, it will retrieve related RModuleAttributes from storage.
1551: *
1552: * This method is protected by default in order to keep the public
1553: * api reasonable. You can provide public methods for those you
1554: * actually need in IssueType.
1555: */
1556: protected List getRModuleAttributesJoinAttribute(Criteria criteria)
1557: throws TorqueException {
1558: if (collRModuleAttributes == null) {
1559: if (isNew()) {
1560: collRModuleAttributes = new ArrayList();
1561: } else {
1562: criteria.add(RModuleAttributePeer.ISSUE_TYPE_ID,
1563: getIssueTypeId());
1564: collRModuleAttributes = RModuleAttributePeer
1565: .doSelectJoinAttribute(criteria);
1566: }
1567: } else {
1568: // the following code is to determine if a new query is
1569: // called for. If the criteria is the same as the last
1570: // one, just return the collection.
1571: criteria.add(RModuleAttributePeer.ISSUE_TYPE_ID,
1572: getIssueTypeId());
1573: if (!lastRModuleAttributesCriteria.equals(criteria)) {
1574: collRModuleAttributes = RModuleAttributePeer
1575: .doSelectJoinAttribute(criteria);
1576: }
1577: }
1578: lastRModuleAttributesCriteria = criteria;
1579:
1580: return collRModuleAttributes;
1581: }
1582:
1583: /**
1584: * If this collection has already been initialized with
1585: * an identical criteria, it returns the collection.
1586: * Otherwise if this IssueType is new, it will return
1587: * an empty collection; or if this IssueType has previously
1588: * been saved, it will retrieve related RModuleAttributes from storage.
1589: *
1590: * This method is protected by default in order to keep the public
1591: * api reasonable. You can provide public methods for those you
1592: * actually need in IssueType.
1593: */
1594: protected List getRModuleAttributesJoinScarabModule(
1595: Criteria criteria) throws TorqueException {
1596: if (collRModuleAttributes == null) {
1597: if (isNew()) {
1598: collRModuleAttributes = new ArrayList();
1599: } else {
1600: criteria.add(RModuleAttributePeer.ISSUE_TYPE_ID,
1601: getIssueTypeId());
1602: collRModuleAttributes = RModuleAttributePeer
1603: .doSelectJoinScarabModule(criteria);
1604: }
1605: } else {
1606: // the following code is to determine if a new query is
1607: // called for. If the criteria is the same as the last
1608: // one, just return the collection.
1609: criteria.add(RModuleAttributePeer.ISSUE_TYPE_ID,
1610: getIssueTypeId());
1611: if (!lastRModuleAttributesCriteria.equals(criteria)) {
1612: collRModuleAttributes = RModuleAttributePeer
1613: .doSelectJoinScarabModule(criteria);
1614: }
1615: }
1616: lastRModuleAttributesCriteria = criteria;
1617:
1618: return collRModuleAttributes;
1619: }
1620:
1621: /**
1622: * If this collection has already been initialized with
1623: * an identical criteria, it returns the collection.
1624: * Otherwise if this IssueType is new, it will return
1625: * an empty collection; or if this IssueType has previously
1626: * been saved, it will retrieve related RModuleAttributes from storage.
1627: *
1628: * This method is protected by default in order to keep the public
1629: * api reasonable. You can provide public methods for those you
1630: * actually need in IssueType.
1631: */
1632: protected List getRModuleAttributesJoinIssueType(Criteria criteria)
1633: throws TorqueException {
1634: if (collRModuleAttributes == null) {
1635: if (isNew()) {
1636: collRModuleAttributes = new ArrayList();
1637: } else {
1638: criteria.add(RModuleAttributePeer.ISSUE_TYPE_ID,
1639: getIssueTypeId());
1640: collRModuleAttributes = RModuleAttributePeer
1641: .doSelectJoinIssueType(criteria);
1642: }
1643: } else {
1644: // the following code is to determine if a new query is
1645: // called for. If the criteria is the same as the last
1646: // one, just return the collection.
1647: criteria.add(RModuleAttributePeer.ISSUE_TYPE_ID,
1648: getIssueTypeId());
1649: if (!lastRModuleAttributesCriteria.equals(criteria)) {
1650: collRModuleAttributes = RModuleAttributePeer
1651: .doSelectJoinIssueType(criteria);
1652: }
1653: }
1654: lastRModuleAttributesCriteria = criteria;
1655:
1656: return collRModuleAttributes;
1657: }
1658:
1659: /**
1660: * Collection to store aggregation of collRIssueTypeAttributes
1661: */
1662: protected List collRIssueTypeAttributes;
1663:
1664: /**
1665: * Temporary storage of collRIssueTypeAttributes to save a possible db hit in
1666: * the event objects are add to the collection, but the
1667: * complete collection is never requested.
1668: */
1669: protected void initRIssueTypeAttributes() {
1670: if (collRIssueTypeAttributes == null) {
1671: collRIssueTypeAttributes = new ArrayList();
1672: }
1673: }
1674:
1675: /**
1676: * Method called to associate a RIssueTypeAttribute object to this object
1677: * through the RIssueTypeAttribute foreign key attribute
1678: *
1679: * @param l RIssueTypeAttribute
1680: * @throws TorqueException
1681: */
1682: public void addRIssueTypeAttribute(RIssueTypeAttribute l)
1683: throws TorqueException {
1684: getRIssueTypeAttributes().add(l);
1685: l.setIssueType((IssueType) this );
1686: }
1687:
1688: /**
1689: * The criteria used to select the current contents of collRIssueTypeAttributes
1690: */
1691: private Criteria lastRIssueTypeAttributesCriteria = null;
1692:
1693: /**
1694: * If this collection has already been initialized, returns
1695: * the collection. Otherwise returns the results of
1696: * getRIssueTypeAttributes(new Criteria())
1697: *
1698: * @return the collection of associated objects
1699: * @throws TorqueException
1700: */
1701: public List getRIssueTypeAttributes() throws TorqueException {
1702: if (collRIssueTypeAttributes == null) {
1703: collRIssueTypeAttributes = getRIssueTypeAttributes(new Criteria(
1704: 10));
1705: }
1706: return collRIssueTypeAttributes;
1707: }
1708:
1709: /**
1710: * If this collection has already been initialized with
1711: * an identical criteria, it returns the collection.
1712: * Otherwise if this IssueType has previously
1713: * been saved, it will retrieve related RIssueTypeAttributes from storage.
1714: * If this IssueType is new, it will return
1715: * an empty collection or the current collection, the criteria
1716: * is ignored on a new object.
1717: *
1718: * @throws TorqueException
1719: */
1720: public List getRIssueTypeAttributes(Criteria criteria)
1721: throws TorqueException {
1722: if (collRIssueTypeAttributes == null) {
1723: if (isNew()) {
1724: collRIssueTypeAttributes = new ArrayList();
1725: } else {
1726: criteria.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
1727: getIssueTypeId());
1728: collRIssueTypeAttributes = RIssueTypeAttributePeer
1729: .doSelect(criteria);
1730: }
1731: } else {
1732: // criteria has no effect for a new object
1733: if (!isNew()) {
1734: // the following code is to determine if a new query is
1735: // called for. If the criteria is the same as the last
1736: // one, just return the collection.
1737: criteria.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
1738: getIssueTypeId());
1739: if (!lastRIssueTypeAttributesCriteria.equals(criteria)) {
1740: collRIssueTypeAttributes = RIssueTypeAttributePeer
1741: .doSelect(criteria);
1742: }
1743: }
1744: }
1745: lastRIssueTypeAttributesCriteria = criteria;
1746:
1747: return collRIssueTypeAttributes;
1748: }
1749:
1750: /**
1751: * If this collection has already been initialized, returns
1752: * the collection. Otherwise returns the results of
1753: * getRIssueTypeAttributes(new Criteria(),Connection)
1754: * This method takes in the Connection also as input so that
1755: * referenced objects can also be obtained using a Connection
1756: * that is taken as input
1757: */
1758: public List getRIssueTypeAttributes(Connection con)
1759: throws TorqueException {
1760: if (collRIssueTypeAttributes == null) {
1761: collRIssueTypeAttributes = getRIssueTypeAttributes(
1762: new Criteria(10), con);
1763: }
1764: return collRIssueTypeAttributes;
1765: }
1766:
1767: /**
1768: * If this collection has already been initialized with
1769: * an identical criteria, it returns the collection.
1770: * Otherwise if this IssueType has previously
1771: * been saved, it will retrieve related RIssueTypeAttributes from storage.
1772: * If this IssueType is new, it will return
1773: * an empty collection or the current collection, the criteria
1774: * is ignored on a new object.
1775: * This method takes in the Connection also as input so that
1776: * referenced objects can also be obtained using a Connection
1777: * that is taken as input
1778: */
1779: public List getRIssueTypeAttributes(Criteria criteria,
1780: Connection con) throws TorqueException {
1781: if (collRIssueTypeAttributes == null) {
1782: if (isNew()) {
1783: collRIssueTypeAttributes = new ArrayList();
1784: } else {
1785: criteria.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
1786: getIssueTypeId());
1787: collRIssueTypeAttributes = RIssueTypeAttributePeer
1788: .doSelect(criteria, con);
1789: }
1790: } else {
1791: // criteria has no effect for a new object
1792: if (!isNew()) {
1793: // the following code is to determine if a new query is
1794: // called for. If the criteria is the same as the last
1795: // one, just return the collection.
1796: criteria.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
1797: getIssueTypeId());
1798: if (!lastRIssueTypeAttributesCriteria.equals(criteria)) {
1799: collRIssueTypeAttributes = RIssueTypeAttributePeer
1800: .doSelect(criteria, con);
1801: }
1802: }
1803: }
1804: lastRIssueTypeAttributesCriteria = criteria;
1805:
1806: return collRIssueTypeAttributes;
1807: }
1808:
1809: /**
1810: * If this collection has already been initialized with
1811: * an identical criteria, it returns the collection.
1812: * Otherwise if this IssueType is new, it will return
1813: * an empty collection; or if this IssueType has previously
1814: * been saved, it will retrieve related RIssueTypeAttributes from storage.
1815: *
1816: * This method is protected by default in order to keep the public
1817: * api reasonable. You can provide public methods for those you
1818: * actually need in IssueType.
1819: */
1820: protected List getRIssueTypeAttributesJoinAttribute(
1821: Criteria criteria) throws TorqueException {
1822: if (collRIssueTypeAttributes == null) {
1823: if (isNew()) {
1824: collRIssueTypeAttributes = new ArrayList();
1825: } else {
1826: criteria.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
1827: getIssueTypeId());
1828: collRIssueTypeAttributes = RIssueTypeAttributePeer
1829: .doSelectJoinAttribute(criteria);
1830: }
1831: } else {
1832: // the following code is to determine if a new query is
1833: // called for. If the criteria is the same as the last
1834: // one, just return the collection.
1835: criteria.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
1836: getIssueTypeId());
1837: if (!lastRIssueTypeAttributesCriteria.equals(criteria)) {
1838: collRIssueTypeAttributes = RIssueTypeAttributePeer
1839: .doSelectJoinAttribute(criteria);
1840: }
1841: }
1842: lastRIssueTypeAttributesCriteria = criteria;
1843:
1844: return collRIssueTypeAttributes;
1845: }
1846:
1847: /**
1848: * If this collection has already been initialized with
1849: * an identical criteria, it returns the collection.
1850: * Otherwise if this IssueType is new, it will return
1851: * an empty collection; or if this IssueType has previously
1852: * been saved, it will retrieve related RIssueTypeAttributes from storage.
1853: *
1854: * This method is protected by default in order to keep the public
1855: * api reasonable. You can provide public methods for those you
1856: * actually need in IssueType.
1857: */
1858: protected List getRIssueTypeAttributesJoinIssueType(
1859: Criteria criteria) throws TorqueException {
1860: if (collRIssueTypeAttributes == null) {
1861: if (isNew()) {
1862: collRIssueTypeAttributes = new ArrayList();
1863: } else {
1864: criteria.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
1865: getIssueTypeId());
1866: collRIssueTypeAttributes = RIssueTypeAttributePeer
1867: .doSelectJoinIssueType(criteria);
1868: }
1869: } else {
1870: // the following code is to determine if a new query is
1871: // called for. If the criteria is the same as the last
1872: // one, just return the collection.
1873: criteria.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
1874: getIssueTypeId());
1875: if (!lastRIssueTypeAttributesCriteria.equals(criteria)) {
1876: collRIssueTypeAttributes = RIssueTypeAttributePeer
1877: .doSelectJoinIssueType(criteria);
1878: }
1879: }
1880: lastRIssueTypeAttributesCriteria = criteria;
1881:
1882: return collRIssueTypeAttributes;
1883: }
1884:
1885: /**
1886: * Collection to store aggregation of collRModuleOptions
1887: */
1888: protected List collRModuleOptions;
1889:
1890: /**
1891: * Temporary storage of collRModuleOptions to save a possible db hit in
1892: * the event objects are add to the collection, but the
1893: * complete collection is never requested.
1894: */
1895: protected void initRModuleOptions() {
1896: if (collRModuleOptions == null) {
1897: collRModuleOptions = new ArrayList();
1898: }
1899: }
1900:
1901: /**
1902: * Method called to associate a RModuleOption object to this object
1903: * through the RModuleOption foreign key attribute
1904: *
1905: * @param l RModuleOption
1906: * @throws TorqueException
1907: */
1908: public void addRModuleOption(RModuleOption l)
1909: throws TorqueException {
1910: getRModuleOptions().add(l);
1911: l.setIssueType((IssueType) this );
1912: }
1913:
1914: /**
1915: * The criteria used to select the current contents of collRModuleOptions
1916: */
1917: private Criteria lastRModuleOptionsCriteria = null;
1918:
1919: /**
1920: * If this collection has already been initialized, returns
1921: * the collection. Otherwise returns the results of
1922: * getRModuleOptions(new Criteria())
1923: *
1924: * @return the collection of associated objects
1925: * @throws TorqueException
1926: */
1927: public List getRModuleOptions() throws TorqueException {
1928: if (collRModuleOptions == null) {
1929: collRModuleOptions = getRModuleOptions(new Criteria(10));
1930: }
1931: return collRModuleOptions;
1932: }
1933:
1934: /**
1935: * If this collection has already been initialized with
1936: * an identical criteria, it returns the collection.
1937: * Otherwise if this IssueType has previously
1938: * been saved, it will retrieve related RModuleOptions from storage.
1939: * If this IssueType is new, it will return
1940: * an empty collection or the current collection, the criteria
1941: * is ignored on a new object.
1942: *
1943: * @throws TorqueException
1944: */
1945: public List getRModuleOptions(Criteria criteria)
1946: throws TorqueException {
1947: if (collRModuleOptions == null) {
1948: if (isNew()) {
1949: collRModuleOptions = new ArrayList();
1950: } else {
1951: criteria.add(RModuleOptionPeer.ISSUE_TYPE_ID,
1952: getIssueTypeId());
1953: collRModuleOptions = RModuleOptionPeer
1954: .doSelect(criteria);
1955: }
1956: } else {
1957: // criteria has no effect for a new object
1958: if (!isNew()) {
1959: // the following code is to determine if a new query is
1960: // called for. If the criteria is the same as the last
1961: // one, just return the collection.
1962: criteria.add(RModuleOptionPeer.ISSUE_TYPE_ID,
1963: getIssueTypeId());
1964: if (!lastRModuleOptionsCriteria.equals(criteria)) {
1965: collRModuleOptions = RModuleOptionPeer
1966: .doSelect(criteria);
1967: }
1968: }
1969: }
1970: lastRModuleOptionsCriteria = criteria;
1971:
1972: return collRModuleOptions;
1973: }
1974:
1975: /**
1976: * If this collection has already been initialized, returns
1977: * the collection. Otherwise returns the results of
1978: * getRModuleOptions(new Criteria(),Connection)
1979: * This method takes in the Connection also as input so that
1980: * referenced objects can also be obtained using a Connection
1981: * that is taken as input
1982: */
1983: public List getRModuleOptions(Connection con)
1984: throws TorqueException {
1985: if (collRModuleOptions == null) {
1986: collRModuleOptions = getRModuleOptions(new Criteria(10),
1987: con);
1988: }
1989: return collRModuleOptions;
1990: }
1991:
1992: /**
1993: * If this collection has already been initialized with
1994: * an identical criteria, it returns the collection.
1995: * Otherwise if this IssueType has previously
1996: * been saved, it will retrieve related RModuleOptions from storage.
1997: * If this IssueType is new, it will return
1998: * an empty collection or the current collection, the criteria
1999: * is ignored on a new object.
2000: * This method takes in the Connection also as input so that
2001: * referenced objects can also be obtained using a Connection
2002: * that is taken as input
2003: */
2004: public List getRModuleOptions(Criteria criteria, Connection con)
2005: throws TorqueException {
2006: if (collRModuleOptions == null) {
2007: if (isNew()) {
2008: collRModuleOptions = new ArrayList();
2009: } else {
2010: criteria.add(RModuleOptionPeer.ISSUE_TYPE_ID,
2011: getIssueTypeId());
2012: collRModuleOptions = RModuleOptionPeer.doSelect(
2013: criteria, con);
2014: }
2015: } else {
2016: // criteria has no effect for a new object
2017: if (!isNew()) {
2018: // the following code is to determine if a new query is
2019: // called for. If the criteria is the same as the last
2020: // one, just return the collection.
2021: criteria.add(RModuleOptionPeer.ISSUE_TYPE_ID,
2022: getIssueTypeId());
2023: if (!lastRModuleOptionsCriteria.equals(criteria)) {
2024: collRModuleOptions = RModuleOptionPeer.doSelect(
2025: criteria, con);
2026: }
2027: }
2028: }
2029: lastRModuleOptionsCriteria = criteria;
2030:
2031: return collRModuleOptions;
2032: }
2033:
2034: /**
2035: * If this collection has already been initialized with
2036: * an identical criteria, it returns the collection.
2037: * Otherwise if this IssueType is new, it will return
2038: * an empty collection; or if this IssueType has previously
2039: * been saved, it will retrieve related RModuleOptions from storage.
2040: *
2041: * This method is protected by default in order to keep the public
2042: * api reasonable. You can provide public methods for those you
2043: * actually need in IssueType.
2044: */
2045: protected List getRModuleOptionsJoinAttributeOption(
2046: Criteria criteria) throws TorqueException {
2047: if (collRModuleOptions == null) {
2048: if (isNew()) {
2049: collRModuleOptions = new ArrayList();
2050: } else {
2051: criteria.add(RModuleOptionPeer.ISSUE_TYPE_ID,
2052: getIssueTypeId());
2053: collRModuleOptions = RModuleOptionPeer
2054: .doSelectJoinAttributeOption(criteria);
2055: }
2056: } else {
2057: // the following code is to determine if a new query is
2058: // called for. If the criteria is the same as the last
2059: // one, just return the collection.
2060: criteria.add(RModuleOptionPeer.ISSUE_TYPE_ID,
2061: getIssueTypeId());
2062: if (!lastRModuleOptionsCriteria.equals(criteria)) {
2063: collRModuleOptions = RModuleOptionPeer
2064: .doSelectJoinAttributeOption(criteria);
2065: }
2066: }
2067: lastRModuleOptionsCriteria = criteria;
2068:
2069: return collRModuleOptions;
2070: }
2071:
2072: /**
2073: * If this collection has already been initialized with
2074: * an identical criteria, it returns the collection.
2075: * Otherwise if this IssueType is new, it will return
2076: * an empty collection; or if this IssueType has previously
2077: * been saved, it will retrieve related RModuleOptions from storage.
2078: *
2079: * This method is protected by default in order to keep the public
2080: * api reasonable. You can provide public methods for those you
2081: * actually need in IssueType.
2082: */
2083: protected List getRModuleOptionsJoinScarabModule(Criteria criteria)
2084: throws TorqueException {
2085: if (collRModuleOptions == null) {
2086: if (isNew()) {
2087: collRModuleOptions = new ArrayList();
2088: } else {
2089: criteria.add(RModuleOptionPeer.ISSUE_TYPE_ID,
2090: getIssueTypeId());
2091: collRModuleOptions = RModuleOptionPeer
2092: .doSelectJoinScarabModule(criteria);
2093: }
2094: } else {
2095: // the following code is to determine if a new query is
2096: // called for. If the criteria is the same as the last
2097: // one, just return the collection.
2098: criteria.add(RModuleOptionPeer.ISSUE_TYPE_ID,
2099: getIssueTypeId());
2100: if (!lastRModuleOptionsCriteria.equals(criteria)) {
2101: collRModuleOptions = RModuleOptionPeer
2102: .doSelectJoinScarabModule(criteria);
2103: }
2104: }
2105: lastRModuleOptionsCriteria = criteria;
2106:
2107: return collRModuleOptions;
2108: }
2109:
2110: /**
2111: * If this collection has already been initialized with
2112: * an identical criteria, it returns the collection.
2113: * Otherwise if this IssueType is new, it will return
2114: * an empty collection; or if this IssueType has previously
2115: * been saved, it will retrieve related RModuleOptions from storage.
2116: *
2117: * This method is protected by default in order to keep the public
2118: * api reasonable. You can provide public methods for those you
2119: * actually need in IssueType.
2120: */
2121: protected List getRModuleOptionsJoinIssueType(Criteria criteria)
2122: throws TorqueException {
2123: if (collRModuleOptions == null) {
2124: if (isNew()) {
2125: collRModuleOptions = new ArrayList();
2126: } else {
2127: criteria.add(RModuleOptionPeer.ISSUE_TYPE_ID,
2128: getIssueTypeId());
2129: collRModuleOptions = RModuleOptionPeer
2130: .doSelectJoinIssueType(criteria);
2131: }
2132: } else {
2133: // the following code is to determine if a new query is
2134: // called for. If the criteria is the same as the last
2135: // one, just return the collection.
2136: criteria.add(RModuleOptionPeer.ISSUE_TYPE_ID,
2137: getIssueTypeId());
2138: if (!lastRModuleOptionsCriteria.equals(criteria)) {
2139: collRModuleOptions = RModuleOptionPeer
2140: .doSelectJoinIssueType(criteria);
2141: }
2142: }
2143: lastRModuleOptionsCriteria = criteria;
2144:
2145: return collRModuleOptions;
2146: }
2147:
2148: /**
2149: * Collection to store aggregation of collRIssueTypeOptions
2150: */
2151: protected List collRIssueTypeOptions;
2152:
2153: /**
2154: * Temporary storage of collRIssueTypeOptions to save a possible db hit in
2155: * the event objects are add to the collection, but the
2156: * complete collection is never requested.
2157: */
2158: protected void initRIssueTypeOptions() {
2159: if (collRIssueTypeOptions == null) {
2160: collRIssueTypeOptions = new ArrayList();
2161: }
2162: }
2163:
2164: /**
2165: * Method called to associate a RIssueTypeOption object to this object
2166: * through the RIssueTypeOption foreign key attribute
2167: *
2168: * @param l RIssueTypeOption
2169: * @throws TorqueException
2170: */
2171: public void addRIssueTypeOption(RIssueTypeOption l)
2172: throws TorqueException {
2173: getRIssueTypeOptions().add(l);
2174: l.setIssueType((IssueType) this );
2175: }
2176:
2177: /**
2178: * The criteria used to select the current contents of collRIssueTypeOptions
2179: */
2180: private Criteria lastRIssueTypeOptionsCriteria = null;
2181:
2182: /**
2183: * If this collection has already been initialized, returns
2184: * the collection. Otherwise returns the results of
2185: * getRIssueTypeOptions(new Criteria())
2186: *
2187: * @return the collection of associated objects
2188: * @throws TorqueException
2189: */
2190: public List getRIssueTypeOptions() throws TorqueException {
2191: if (collRIssueTypeOptions == null) {
2192: collRIssueTypeOptions = getRIssueTypeOptions(new Criteria(
2193: 10));
2194: }
2195: return collRIssueTypeOptions;
2196: }
2197:
2198: /**
2199: * If this collection has already been initialized with
2200: * an identical criteria, it returns the collection.
2201: * Otherwise if this IssueType has previously
2202: * been saved, it will retrieve related RIssueTypeOptions from storage.
2203: * If this IssueType is new, it will return
2204: * an empty collection or the current collection, the criteria
2205: * is ignored on a new object.
2206: *
2207: * @throws TorqueException
2208: */
2209: public List getRIssueTypeOptions(Criteria criteria)
2210: throws TorqueException {
2211: if (collRIssueTypeOptions == null) {
2212: if (isNew()) {
2213: collRIssueTypeOptions = new ArrayList();
2214: } else {
2215: criteria.add(RIssueTypeOptionPeer.ISSUE_TYPE_ID,
2216: getIssueTypeId());
2217: collRIssueTypeOptions = RIssueTypeOptionPeer
2218: .doSelect(criteria);
2219: }
2220: } else {
2221: // criteria has no effect for a new object
2222: if (!isNew()) {
2223: // the following code is to determine if a new query is
2224: // called for. If the criteria is the same as the last
2225: // one, just return the collection.
2226: criteria.add(RIssueTypeOptionPeer.ISSUE_TYPE_ID,
2227: getIssueTypeId());
2228: if (!lastRIssueTypeOptionsCriteria.equals(criteria)) {
2229: collRIssueTypeOptions = RIssueTypeOptionPeer
2230: .doSelect(criteria);
2231: }
2232: }
2233: }
2234: lastRIssueTypeOptionsCriteria = criteria;
2235:
2236: return collRIssueTypeOptions;
2237: }
2238:
2239: /**
2240: * If this collection has already been initialized, returns
2241: * the collection. Otherwise returns the results of
2242: * getRIssueTypeOptions(new Criteria(),Connection)
2243: * This method takes in the Connection also as input so that
2244: * referenced objects can also be obtained using a Connection
2245: * that is taken as input
2246: */
2247: public List getRIssueTypeOptions(Connection con)
2248: throws TorqueException {
2249: if (collRIssueTypeOptions == null) {
2250: collRIssueTypeOptions = getRIssueTypeOptions(new Criteria(
2251: 10), con);
2252: }
2253: return collRIssueTypeOptions;
2254: }
2255:
2256: /**
2257: * If this collection has already been initialized with
2258: * an identical criteria, it returns the collection.
2259: * Otherwise if this IssueType has previously
2260: * been saved, it will retrieve related RIssueTypeOptions from storage.
2261: * If this IssueType is new, it will return
2262: * an empty collection or the current collection, the criteria
2263: * is ignored on a new object.
2264: * This method takes in the Connection also as input so that
2265: * referenced objects can also be obtained using a Connection
2266: * that is taken as input
2267: */
2268: public List getRIssueTypeOptions(Criteria criteria, Connection con)
2269: throws TorqueException {
2270: if (collRIssueTypeOptions == null) {
2271: if (isNew()) {
2272: collRIssueTypeOptions = new ArrayList();
2273: } else {
2274: criteria.add(RIssueTypeOptionPeer.ISSUE_TYPE_ID,
2275: getIssueTypeId());
2276: collRIssueTypeOptions = RIssueTypeOptionPeer.doSelect(
2277: criteria, con);
2278: }
2279: } else {
2280: // criteria has no effect for a new object
2281: if (!isNew()) {
2282: // the following code is to determine if a new query is
2283: // called for. If the criteria is the same as the last
2284: // one, just return the collection.
2285: criteria.add(RIssueTypeOptionPeer.ISSUE_TYPE_ID,
2286: getIssueTypeId());
2287: if (!lastRIssueTypeOptionsCriteria.equals(criteria)) {
2288: collRIssueTypeOptions = RIssueTypeOptionPeer
2289: .doSelect(criteria, con);
2290: }
2291: }
2292: }
2293: lastRIssueTypeOptionsCriteria = criteria;
2294:
2295: return collRIssueTypeOptions;
2296: }
2297:
2298: /**
2299: * If this collection has already been initialized with
2300: * an identical criteria, it returns the collection.
2301: * Otherwise if this IssueType is new, it will return
2302: * an empty collection; or if this IssueType has previously
2303: * been saved, it will retrieve related RIssueTypeOptions from storage.
2304: *
2305: * This method is protected by default in order to keep the public
2306: * api reasonable. You can provide public methods for those you
2307: * actually need in IssueType.
2308: */
2309: protected List getRIssueTypeOptionsJoinAttributeOption(
2310: Criteria criteria) throws TorqueException {
2311: if (collRIssueTypeOptions == null) {
2312: if (isNew()) {
2313: collRIssueTypeOptions = new ArrayList();
2314: } else {
2315: criteria.add(RIssueTypeOptionPeer.ISSUE_TYPE_ID,
2316: getIssueTypeId());
2317: collRIssueTypeOptions = RIssueTypeOptionPeer
2318: .doSelectJoinAttributeOption(criteria);
2319: }
2320: } else {
2321: // the following code is to determine if a new query is
2322: // called for. If the criteria is the same as the last
2323: // one, just return the collection.
2324: criteria.add(RIssueTypeOptionPeer.ISSUE_TYPE_ID,
2325: getIssueTypeId());
2326: if (!lastRIssueTypeOptionsCriteria.equals(criteria)) {
2327: collRIssueTypeOptions = RIssueTypeOptionPeer
2328: .doSelectJoinAttributeOption(criteria);
2329: }
2330: }
2331: lastRIssueTypeOptionsCriteria = criteria;
2332:
2333: return collRIssueTypeOptions;
2334: }
2335:
2336: /**
2337: * If this collection has already been initialized with
2338: * an identical criteria, it returns the collection.
2339: * Otherwise if this IssueType is new, it will return
2340: * an empty collection; or if this IssueType has previously
2341: * been saved, it will retrieve related RIssueTypeOptions from storage.
2342: *
2343: * This method is protected by default in order to keep the public
2344: * api reasonable. You can provide public methods for those you
2345: * actually need in IssueType.
2346: */
2347: protected List getRIssueTypeOptionsJoinIssueType(Criteria criteria)
2348: throws TorqueException {
2349: if (collRIssueTypeOptions == null) {
2350: if (isNew()) {
2351: collRIssueTypeOptions = new ArrayList();
2352: } else {
2353: criteria.add(RIssueTypeOptionPeer.ISSUE_TYPE_ID,
2354: getIssueTypeId());
2355: collRIssueTypeOptions = RIssueTypeOptionPeer
2356: .doSelectJoinIssueType(criteria);
2357: }
2358: } else {
2359: // the following code is to determine if a new query is
2360: // called for. If the criteria is the same as the last
2361: // one, just return the collection.
2362: criteria.add(RIssueTypeOptionPeer.ISSUE_TYPE_ID,
2363: getIssueTypeId());
2364: if (!lastRIssueTypeOptionsCriteria.equals(criteria)) {
2365: collRIssueTypeOptions = RIssueTypeOptionPeer
2366: .doSelectJoinIssueType(criteria);
2367: }
2368: }
2369: lastRIssueTypeOptionsCriteria = criteria;
2370:
2371: return collRIssueTypeOptions;
2372: }
2373:
2374: /**
2375: * Collection to store aggregation of collRModuleUserAttributes
2376: */
2377: protected List collRModuleUserAttributes;
2378:
2379: /**
2380: * Temporary storage of collRModuleUserAttributes to save a possible db hit in
2381: * the event objects are add to the collection, but the
2382: * complete collection is never requested.
2383: */
2384: protected void initRModuleUserAttributes() {
2385: if (collRModuleUserAttributes == null) {
2386: collRModuleUserAttributes = new ArrayList();
2387: }
2388: }
2389:
2390: /**
2391: * Method called to associate a RModuleUserAttribute object to this object
2392: * through the RModuleUserAttribute foreign key attribute
2393: *
2394: * @param l RModuleUserAttribute
2395: * @throws TorqueException
2396: */
2397: public void addRModuleUserAttribute(RModuleUserAttribute l)
2398: throws TorqueException {
2399: getRModuleUserAttributes().add(l);
2400: l.setIssueType((IssueType) this );
2401: }
2402:
2403: /**
2404: * The criteria used to select the current contents of collRModuleUserAttributes
2405: */
2406: private Criteria lastRModuleUserAttributesCriteria = null;
2407:
2408: /**
2409: * If this collection has already been initialized, returns
2410: * the collection. Otherwise returns the results of
2411: * getRModuleUserAttributes(new Criteria())
2412: *
2413: * @return the collection of associated objects
2414: * @throws TorqueException
2415: */
2416: public List getRModuleUserAttributes() throws TorqueException {
2417: if (collRModuleUserAttributes == null) {
2418: collRModuleUserAttributes = getRModuleUserAttributes(new Criteria(
2419: 10));
2420: }
2421: return collRModuleUserAttributes;
2422: }
2423:
2424: /**
2425: * If this collection has already been initialized with
2426: * an identical criteria, it returns the collection.
2427: * Otherwise if this IssueType has previously
2428: * been saved, it will retrieve related RModuleUserAttributes from storage.
2429: * If this IssueType is new, it will return
2430: * an empty collection or the current collection, the criteria
2431: * is ignored on a new object.
2432: *
2433: * @throws TorqueException
2434: */
2435: public List getRModuleUserAttributes(Criteria criteria)
2436: throws TorqueException {
2437: if (collRModuleUserAttributes == null) {
2438: if (isNew()) {
2439: collRModuleUserAttributes = new ArrayList();
2440: } else {
2441: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2442: getIssueTypeId());
2443: collRModuleUserAttributes = RModuleUserAttributePeer
2444: .doSelect(criteria);
2445: }
2446: } else {
2447: // criteria has no effect for a new object
2448: if (!isNew()) {
2449: // the following code is to determine if a new query is
2450: // called for. If the criteria is the same as the last
2451: // one, just return the collection.
2452: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2453: getIssueTypeId());
2454: if (!lastRModuleUserAttributesCriteria.equals(criteria)) {
2455: collRModuleUserAttributes = RModuleUserAttributePeer
2456: .doSelect(criteria);
2457: }
2458: }
2459: }
2460: lastRModuleUserAttributesCriteria = criteria;
2461:
2462: return collRModuleUserAttributes;
2463: }
2464:
2465: /**
2466: * If this collection has already been initialized, returns
2467: * the collection. Otherwise returns the results of
2468: * getRModuleUserAttributes(new Criteria(),Connection)
2469: * This method takes in the Connection also as input so that
2470: * referenced objects can also be obtained using a Connection
2471: * that is taken as input
2472: */
2473: public List getRModuleUserAttributes(Connection con)
2474: throws TorqueException {
2475: if (collRModuleUserAttributes == null) {
2476: collRModuleUserAttributes = getRModuleUserAttributes(
2477: new Criteria(10), con);
2478: }
2479: return collRModuleUserAttributes;
2480: }
2481:
2482: /**
2483: * If this collection has already been initialized with
2484: * an identical criteria, it returns the collection.
2485: * Otherwise if this IssueType has previously
2486: * been saved, it will retrieve related RModuleUserAttributes from storage.
2487: * If this IssueType is new, it will return
2488: * an empty collection or the current collection, the criteria
2489: * is ignored on a new object.
2490: * This method takes in the Connection also as input so that
2491: * referenced objects can also be obtained using a Connection
2492: * that is taken as input
2493: */
2494: public List getRModuleUserAttributes(Criteria criteria,
2495: Connection con) throws TorqueException {
2496: if (collRModuleUserAttributes == null) {
2497: if (isNew()) {
2498: collRModuleUserAttributes = new ArrayList();
2499: } else {
2500: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2501: getIssueTypeId());
2502: collRModuleUserAttributes = RModuleUserAttributePeer
2503: .doSelect(criteria, con);
2504: }
2505: } else {
2506: // criteria has no effect for a new object
2507: if (!isNew()) {
2508: // the following code is to determine if a new query is
2509: // called for. If the criteria is the same as the last
2510: // one, just return the collection.
2511: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2512: getIssueTypeId());
2513: if (!lastRModuleUserAttributesCriteria.equals(criteria)) {
2514: collRModuleUserAttributes = RModuleUserAttributePeer
2515: .doSelect(criteria, con);
2516: }
2517: }
2518: }
2519: lastRModuleUserAttributesCriteria = criteria;
2520:
2521: return collRModuleUserAttributes;
2522: }
2523:
2524: /**
2525: * If this collection has already been initialized with
2526: * an identical criteria, it returns the collection.
2527: * Otherwise if this IssueType is new, it will return
2528: * an empty collection; or if this IssueType has previously
2529: * been saved, it will retrieve related RModuleUserAttributes from storage.
2530: *
2531: * This method is protected by default in order to keep the public
2532: * api reasonable. You can provide public methods for those you
2533: * actually need in IssueType.
2534: */
2535: protected List getRModuleUserAttributesJoinMITList(Criteria criteria)
2536: throws TorqueException {
2537: if (collRModuleUserAttributes == null) {
2538: if (isNew()) {
2539: collRModuleUserAttributes = new ArrayList();
2540: } else {
2541: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2542: getIssueTypeId());
2543: collRModuleUserAttributes = RModuleUserAttributePeer
2544: .doSelectJoinMITList(criteria);
2545: }
2546: } else {
2547: // the following code is to determine if a new query is
2548: // called for. If the criteria is the same as the last
2549: // one, just return the collection.
2550: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2551: getIssueTypeId());
2552: if (!lastRModuleUserAttributesCriteria.equals(criteria)) {
2553: collRModuleUserAttributes = RModuleUserAttributePeer
2554: .doSelectJoinMITList(criteria);
2555: }
2556: }
2557: lastRModuleUserAttributesCriteria = criteria;
2558:
2559: return collRModuleUserAttributes;
2560: }
2561:
2562: /**
2563: * If this collection has already been initialized with
2564: * an identical criteria, it returns the collection.
2565: * Otherwise if this IssueType is new, it will return
2566: * an empty collection; or if this IssueType has previously
2567: * been saved, it will retrieve related RModuleUserAttributes from storage.
2568: *
2569: * This method is protected by default in order to keep the public
2570: * api reasonable. You can provide public methods for those you
2571: * actually need in IssueType.
2572: */
2573: protected List getRModuleUserAttributesJoinScarabModule(
2574: Criteria criteria) throws TorqueException {
2575: if (collRModuleUserAttributes == null) {
2576: if (isNew()) {
2577: collRModuleUserAttributes = new ArrayList();
2578: } else {
2579: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2580: getIssueTypeId());
2581: collRModuleUserAttributes = RModuleUserAttributePeer
2582: .doSelectJoinScarabModule(criteria);
2583: }
2584: } else {
2585: // the following code is to determine if a new query is
2586: // called for. If the criteria is the same as the last
2587: // one, just return the collection.
2588: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2589: getIssueTypeId());
2590: if (!lastRModuleUserAttributesCriteria.equals(criteria)) {
2591: collRModuleUserAttributes = RModuleUserAttributePeer
2592: .doSelectJoinScarabModule(criteria);
2593: }
2594: }
2595: lastRModuleUserAttributesCriteria = criteria;
2596:
2597: return collRModuleUserAttributes;
2598: }
2599:
2600: /**
2601: * If this collection has already been initialized with
2602: * an identical criteria, it returns the collection.
2603: * Otherwise if this IssueType is new, it will return
2604: * an empty collection; or if this IssueType has previously
2605: * been saved, it will retrieve related RModuleUserAttributes from storage.
2606: *
2607: * This method is protected by default in order to keep the public
2608: * api reasonable. You can provide public methods for those you
2609: * actually need in IssueType.
2610: */
2611: protected List getRModuleUserAttributesJoinScarabUserImpl(
2612: Criteria criteria) throws TorqueException {
2613: if (collRModuleUserAttributes == null) {
2614: if (isNew()) {
2615: collRModuleUserAttributes = new ArrayList();
2616: } else {
2617: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2618: getIssueTypeId());
2619: collRModuleUserAttributes = RModuleUserAttributePeer
2620: .doSelectJoinScarabUserImpl(criteria);
2621: }
2622: } else {
2623: // the following code is to determine if a new query is
2624: // called for. If the criteria is the same as the last
2625: // one, just return the collection.
2626: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2627: getIssueTypeId());
2628: if (!lastRModuleUserAttributesCriteria.equals(criteria)) {
2629: collRModuleUserAttributes = RModuleUserAttributePeer
2630: .doSelectJoinScarabUserImpl(criteria);
2631: }
2632: }
2633: lastRModuleUserAttributesCriteria = criteria;
2634:
2635: return collRModuleUserAttributes;
2636: }
2637:
2638: /**
2639: * If this collection has already been initialized with
2640: * an identical criteria, it returns the collection.
2641: * Otherwise if this IssueType is new, it will return
2642: * an empty collection; or if this IssueType has previously
2643: * been saved, it will retrieve related RModuleUserAttributes from storage.
2644: *
2645: * This method is protected by default in order to keep the public
2646: * api reasonable. You can provide public methods for those you
2647: * actually need in IssueType.
2648: */
2649: protected List getRModuleUserAttributesJoinIssueType(
2650: Criteria criteria) throws TorqueException {
2651: if (collRModuleUserAttributes == null) {
2652: if (isNew()) {
2653: collRModuleUserAttributes = new ArrayList();
2654: } else {
2655: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2656: getIssueTypeId());
2657: collRModuleUserAttributes = RModuleUserAttributePeer
2658: .doSelectJoinIssueType(criteria);
2659: }
2660: } else {
2661: // the following code is to determine if a new query is
2662: // called for. If the criteria is the same as the last
2663: // one, just return the collection.
2664: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2665: getIssueTypeId());
2666: if (!lastRModuleUserAttributesCriteria.equals(criteria)) {
2667: collRModuleUserAttributes = RModuleUserAttributePeer
2668: .doSelectJoinIssueType(criteria);
2669: }
2670: }
2671: lastRModuleUserAttributesCriteria = criteria;
2672:
2673: return collRModuleUserAttributes;
2674: }
2675:
2676: /**
2677: * If this collection has already been initialized with
2678: * an identical criteria, it returns the collection.
2679: * Otherwise if this IssueType is new, it will return
2680: * an empty collection; or if this IssueType has previously
2681: * been saved, it will retrieve related RModuleUserAttributes from storage.
2682: *
2683: * This method is protected by default in order to keep the public
2684: * api reasonable. You can provide public methods for those you
2685: * actually need in IssueType.
2686: */
2687: protected List getRModuleUserAttributesJoinAttribute(
2688: Criteria criteria) throws TorqueException {
2689: if (collRModuleUserAttributes == null) {
2690: if (isNew()) {
2691: collRModuleUserAttributes = new ArrayList();
2692: } else {
2693: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2694: getIssueTypeId());
2695: collRModuleUserAttributes = RModuleUserAttributePeer
2696: .doSelectJoinAttribute(criteria);
2697: }
2698: } else {
2699: // the following code is to determine if a new query is
2700: // called for. If the criteria is the same as the last
2701: // one, just return the collection.
2702: criteria.add(RModuleUserAttributePeer.ISSUE_TYPE_ID,
2703: getIssueTypeId());
2704: if (!lastRModuleUserAttributesCriteria.equals(criteria)) {
2705: collRModuleUserAttributes = RModuleUserAttributePeer
2706: .doSelectJoinAttribute(criteria);
2707: }
2708: }
2709: lastRModuleUserAttributesCriteria = criteria;
2710:
2711: return collRModuleUserAttributes;
2712: }
2713:
2714: /**
2715: * Collection to store aggregation of collQuerys
2716: */
2717: protected List collQuerys;
2718:
2719: /**
2720: * Temporary storage of collQuerys to save a possible db hit in
2721: * the event objects are add to the collection, but the
2722: * complete collection is never requested.
2723: */
2724: protected void initQuerys() {
2725: if (collQuerys == null) {
2726: collQuerys = new ArrayList();
2727: }
2728: }
2729:
2730: /**
2731: * Method called to associate a Query object to this object
2732: * through the Query foreign key attribute
2733: *
2734: * @param l Query
2735: * @throws TorqueException
2736: */
2737: public void addQuery(Query l) throws TorqueException {
2738: getQuerys().add(l);
2739: l.setIssueType((IssueType) this );
2740: }
2741:
2742: /**
2743: * The criteria used to select the current contents of collQuerys
2744: */
2745: private Criteria lastQuerysCriteria = null;
2746:
2747: /**
2748: * If this collection has already been initialized, returns
2749: * the collection. Otherwise returns the results of
2750: * getQuerys(new Criteria())
2751: *
2752: * @return the collection of associated objects
2753: * @throws TorqueException
2754: */
2755: public List getQuerys() throws TorqueException {
2756: if (collQuerys == null) {
2757: collQuerys = getQuerys(new Criteria(10));
2758: }
2759: return collQuerys;
2760: }
2761:
2762: /**
2763: * If this collection has already been initialized with
2764: * an identical criteria, it returns the collection.
2765: * Otherwise if this IssueType has previously
2766: * been saved, it will retrieve related Querys from storage.
2767: * If this IssueType is new, it will return
2768: * an empty collection or the current collection, the criteria
2769: * is ignored on a new object.
2770: *
2771: * @throws TorqueException
2772: */
2773: public List getQuerys(Criteria criteria) throws TorqueException {
2774: if (collQuerys == null) {
2775: if (isNew()) {
2776: collQuerys = new ArrayList();
2777: } else {
2778: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
2779: collQuerys = QueryPeer.doSelect(criteria);
2780: }
2781: } else {
2782: // criteria has no effect for a new object
2783: if (!isNew()) {
2784: // the following code is to determine if a new query is
2785: // called for. If the criteria is the same as the last
2786: // one, just return the collection.
2787: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
2788: if (!lastQuerysCriteria.equals(criteria)) {
2789: collQuerys = QueryPeer.doSelect(criteria);
2790: }
2791: }
2792: }
2793: lastQuerysCriteria = criteria;
2794:
2795: return collQuerys;
2796: }
2797:
2798: /**
2799: * If this collection has already been initialized, returns
2800: * the collection. Otherwise returns the results of
2801: * getQuerys(new Criteria(),Connection)
2802: * This method takes in the Connection also as input so that
2803: * referenced objects can also be obtained using a Connection
2804: * that is taken as input
2805: */
2806: public List getQuerys(Connection con) throws TorqueException {
2807: if (collQuerys == null) {
2808: collQuerys = getQuerys(new Criteria(10), con);
2809: }
2810: return collQuerys;
2811: }
2812:
2813: /**
2814: * If this collection has already been initialized with
2815: * an identical criteria, it returns the collection.
2816: * Otherwise if this IssueType has previously
2817: * been saved, it will retrieve related Querys from storage.
2818: * If this IssueType is new, it will return
2819: * an empty collection or the current collection, the criteria
2820: * is ignored on a new object.
2821: * This method takes in the Connection also as input so that
2822: * referenced objects can also be obtained using a Connection
2823: * that is taken as input
2824: */
2825: public List getQuerys(Criteria criteria, Connection con)
2826: throws TorqueException {
2827: if (collQuerys == null) {
2828: if (isNew()) {
2829: collQuerys = new ArrayList();
2830: } else {
2831: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
2832: collQuerys = QueryPeer.doSelect(criteria, con);
2833: }
2834: } else {
2835: // criteria has no effect for a new object
2836: if (!isNew()) {
2837: // the following code is to determine if a new query is
2838: // called for. If the criteria is the same as the last
2839: // one, just return the collection.
2840: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
2841: if (!lastQuerysCriteria.equals(criteria)) {
2842: collQuerys = QueryPeer.doSelect(criteria, con);
2843: }
2844: }
2845: }
2846: lastQuerysCriteria = criteria;
2847:
2848: return collQuerys;
2849: }
2850:
2851: /**
2852: * If this collection has already been initialized with
2853: * an identical criteria, it returns the collection.
2854: * Otherwise if this IssueType is new, it will return
2855: * an empty collection; or if this IssueType has previously
2856: * been saved, it will retrieve related Querys from storage.
2857: *
2858: * This method is protected by default in order to keep the public
2859: * api reasonable. You can provide public methods for those you
2860: * actually need in IssueType.
2861: */
2862: protected List getQuerysJoinScarabUserImpl(Criteria criteria)
2863: throws TorqueException {
2864: if (collQuerys == null) {
2865: if (isNew()) {
2866: collQuerys = new ArrayList();
2867: } else {
2868: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
2869: collQuerys = QueryPeer
2870: .doSelectJoinScarabUserImpl(criteria);
2871: }
2872: } else {
2873: // the following code is to determine if a new query is
2874: // called for. If the criteria is the same as the last
2875: // one, just return the collection.
2876: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
2877: if (!lastQuerysCriteria.equals(criteria)) {
2878: collQuerys = QueryPeer
2879: .doSelectJoinScarabUserImpl(criteria);
2880: }
2881: }
2882: lastQuerysCriteria = criteria;
2883:
2884: return collQuerys;
2885: }
2886:
2887: /**
2888: * If this collection has already been initialized with
2889: * an identical criteria, it returns the collection.
2890: * Otherwise if this IssueType is new, it will return
2891: * an empty collection; or if this IssueType has previously
2892: * been saved, it will retrieve related Querys from storage.
2893: *
2894: * This method is protected by default in order to keep the public
2895: * api reasonable. You can provide public methods for those you
2896: * actually need in IssueType.
2897: */
2898: protected List getQuerysJoinScope(Criteria criteria)
2899: throws TorqueException {
2900: if (collQuerys == null) {
2901: if (isNew()) {
2902: collQuerys = new ArrayList();
2903: } else {
2904: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
2905: collQuerys = QueryPeer.doSelectJoinScope(criteria);
2906: }
2907: } else {
2908: // the following code is to determine if a new query is
2909: // called for. If the criteria is the same as the last
2910: // one, just return the collection.
2911: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
2912: if (!lastQuerysCriteria.equals(criteria)) {
2913: collQuerys = QueryPeer.doSelectJoinScope(criteria);
2914: }
2915: }
2916: lastQuerysCriteria = criteria;
2917:
2918: return collQuerys;
2919: }
2920:
2921: /**
2922: * If this collection has already been initialized with
2923: * an identical criteria, it returns the collection.
2924: * Otherwise if this IssueType is new, it will return
2925: * an empty collection; or if this IssueType has previously
2926: * been saved, it will retrieve related Querys from storage.
2927: *
2928: * This method is protected by default in order to keep the public
2929: * api reasonable. You can provide public methods for those you
2930: * actually need in IssueType.
2931: */
2932: protected List getQuerysJoinScarabModule(Criteria criteria)
2933: throws TorqueException {
2934: if (collQuerys == null) {
2935: if (isNew()) {
2936: collQuerys = new ArrayList();
2937: } else {
2938: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
2939: collQuerys = QueryPeer
2940: .doSelectJoinScarabModule(criteria);
2941: }
2942: } else {
2943: // the following code is to determine if a new query is
2944: // called for. If the criteria is the same as the last
2945: // one, just return the collection.
2946: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
2947: if (!lastQuerysCriteria.equals(criteria)) {
2948: collQuerys = QueryPeer
2949: .doSelectJoinScarabModule(criteria);
2950: }
2951: }
2952: lastQuerysCriteria = criteria;
2953:
2954: return collQuerys;
2955: }
2956:
2957: /**
2958: * If this collection has already been initialized with
2959: * an identical criteria, it returns the collection.
2960: * Otherwise if this IssueType is new, it will return
2961: * an empty collection; or if this IssueType has previously
2962: * been saved, it will retrieve related Querys from storage.
2963: *
2964: * This method is protected by default in order to keep the public
2965: * api reasonable. You can provide public methods for those you
2966: * actually need in IssueType.
2967: */
2968: protected List getQuerysJoinIssueType(Criteria criteria)
2969: throws TorqueException {
2970: if (collQuerys == null) {
2971: if (isNew()) {
2972: collQuerys = new ArrayList();
2973: } else {
2974: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
2975: collQuerys = QueryPeer.doSelectJoinIssueType(criteria);
2976: }
2977: } else {
2978: // the following code is to determine if a new query is
2979: // called for. If the criteria is the same as the last
2980: // one, just return the collection.
2981: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
2982: if (!lastQuerysCriteria.equals(criteria)) {
2983: collQuerys = QueryPeer.doSelectJoinIssueType(criteria);
2984: }
2985: }
2986: lastQuerysCriteria = criteria;
2987:
2988: return collQuerys;
2989: }
2990:
2991: /**
2992: * If this collection has already been initialized with
2993: * an identical criteria, it returns the collection.
2994: * Otherwise if this IssueType is new, it will return
2995: * an empty collection; or if this IssueType has previously
2996: * been saved, it will retrieve related Querys from storage.
2997: *
2998: * This method is protected by default in order to keep the public
2999: * api reasonable. You can provide public methods for those you
3000: * actually need in IssueType.
3001: */
3002: protected List getQuerysJoinMITList(Criteria criteria)
3003: throws TorqueException {
3004: if (collQuerys == null) {
3005: if (isNew()) {
3006: collQuerys = new ArrayList();
3007: } else {
3008: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
3009: collQuerys = QueryPeer.doSelectJoinMITList(criteria);
3010: }
3011: } else {
3012: // the following code is to determine if a new query is
3013: // called for. If the criteria is the same as the last
3014: // one, just return the collection.
3015: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
3016: if (!lastQuerysCriteria.equals(criteria)) {
3017: collQuerys = QueryPeer.doSelectJoinMITList(criteria);
3018: }
3019: }
3020: lastQuerysCriteria = criteria;
3021:
3022: return collQuerys;
3023: }
3024:
3025: /**
3026: * If this collection has already been initialized with
3027: * an identical criteria, it returns the collection.
3028: * Otherwise if this IssueType is new, it will return
3029: * an empty collection; or if this IssueType has previously
3030: * been saved, it will retrieve related Querys from storage.
3031: *
3032: * This method is protected by default in order to keep the public
3033: * api reasonable. You can provide public methods for those you
3034: * actually need in IssueType.
3035: */
3036: protected List getQuerysJoinFrequency(Criteria criteria)
3037: throws TorqueException {
3038: if (collQuerys == null) {
3039: if (isNew()) {
3040: collQuerys = new ArrayList();
3041: } else {
3042: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
3043: collQuerys = QueryPeer.doSelectJoinFrequency(criteria);
3044: }
3045: } else {
3046: // the following code is to determine if a new query is
3047: // called for. If the criteria is the same as the last
3048: // one, just return the collection.
3049: criteria.add(QueryPeer.ISSUE_TYPE_ID, getIssueTypeId());
3050: if (!lastQuerysCriteria.equals(criteria)) {
3051: collQuerys = QueryPeer.doSelectJoinFrequency(criteria);
3052: }
3053: }
3054: lastQuerysCriteria = criteria;
3055:
3056: return collQuerys;
3057: }
3058:
3059: /**
3060: * Collection to store aggregation of collReports
3061: */
3062: protected List collReports;
3063:
3064: /**
3065: * Temporary storage of collReports to save a possible db hit in
3066: * the event objects are add to the collection, but the
3067: * complete collection is never requested.
3068: */
3069: protected void initReports() {
3070: if (collReports == null) {
3071: collReports = new ArrayList();
3072: }
3073: }
3074:
3075: /**
3076: * Method called to associate a Report object to this object
3077: * through the Report foreign key attribute
3078: *
3079: * @param l Report
3080: * @throws TorqueException
3081: */
3082: public void addReport(Report l) throws TorqueException {
3083: getReports().add(l);
3084: l.setIssueType((IssueType) this );
3085: }
3086:
3087: /**
3088: * The criteria used to select the current contents of collReports
3089: */
3090: private Criteria lastReportsCriteria = null;
3091:
3092: /**
3093: * If this collection has already been initialized, returns
3094: * the collection. Otherwise returns the results of
3095: * getReports(new Criteria())
3096: *
3097: * @return the collection of associated objects
3098: * @throws TorqueException
3099: */
3100: public List getReports() throws TorqueException {
3101: if (collReports == null) {
3102: collReports = getReports(new Criteria(10));
3103: }
3104: return collReports;
3105: }
3106:
3107: /**
3108: * If this collection has already been initialized with
3109: * an identical criteria, it returns the collection.
3110: * Otherwise if this IssueType has previously
3111: * been saved, it will retrieve related Reports from storage.
3112: * If this IssueType is new, it will return
3113: * an empty collection or the current collection, the criteria
3114: * is ignored on a new object.
3115: *
3116: * @throws TorqueException
3117: */
3118: public List getReports(Criteria criteria) throws TorqueException {
3119: if (collReports == null) {
3120: if (isNew()) {
3121: collReports = new ArrayList();
3122: } else {
3123: criteria
3124: .add(ReportPeer.ISSUE_TYPE_ID, getIssueTypeId());
3125: collReports = ReportPeer.doSelect(criteria);
3126: }
3127: } else {
3128: // criteria has no effect for a new object
3129: if (!isNew()) {
3130: // the following code is to determine if a new query is
3131: // called for. If the criteria is the same as the last
3132: // one, just return the collection.
3133: criteria
3134: .add(ReportPeer.ISSUE_TYPE_ID, getIssueTypeId());
3135: if (!lastReportsCriteria.equals(criteria)) {
3136: collReports = ReportPeer.doSelect(criteria);
3137: }
3138: }
3139: }
3140: lastReportsCriteria = criteria;
3141:
3142: return collReports;
3143: }
3144:
3145: /**
3146: * If this collection has already been initialized, returns
3147: * the collection. Otherwise returns the results of
3148: * getReports(new Criteria(),Connection)
3149: * This method takes in the Connection also as input so that
3150: * referenced objects can also be obtained using a Connection
3151: * that is taken as input
3152: */
3153: public List getReports(Connection con) throws TorqueException {
3154: if (collReports == null) {
3155: collReports = getReports(new Criteria(10), con);
3156: }
3157: return collReports;
3158: }
3159:
3160: /**
3161: * If this collection has already been initialized with
3162: * an identical criteria, it returns the collection.
3163: * Otherwise if this IssueType has previously
3164: * been saved, it will retrieve related Reports from storage.
3165: * If this IssueType is new, it will return
3166: * an empty collection or the current collection, the criteria
3167: * is ignored on a new object.
3168: * This method takes in the Connection also as input so that
3169: * referenced objects can also be obtained using a Connection
3170: * that is taken as input
3171: */
3172: public List getReports(Criteria criteria, Connection con)
3173: throws TorqueException {
3174: if (collReports == null) {
3175: if (isNew()) {
3176: collReports = new ArrayList();
3177: } else {
3178: criteria
3179: .add(ReportPeer.ISSUE_TYPE_ID, getIssueTypeId());
3180: collReports = ReportPeer.doSelect(criteria, con);
3181: }
3182: } else {
3183: // criteria has no effect for a new object
3184: if (!isNew()) {
3185: // the following code is to determine if a new query is
3186: // called for. If the criteria is the same as the last
3187: // one, just return the collection.
3188: criteria
3189: .add(ReportPeer.ISSUE_TYPE_ID, getIssueTypeId());
3190: if (!lastReportsCriteria.equals(criteria)) {
3191: collReports = ReportPeer.doSelect(criteria, con);
3192: }
3193: }
3194: }
3195: lastReportsCriteria = criteria;
3196:
3197: return collReports;
3198: }
3199:
3200: /**
3201: * If this collection has already been initialized with
3202: * an identical criteria, it returns the collection.
3203: * Otherwise if this IssueType is new, it will return
3204: * an empty collection; or if this IssueType has previously
3205: * been saved, it will retrieve related Reports from storage.
3206: *
3207: * This method is protected by default in order to keep the public
3208: * api reasonable. You can provide public methods for those you
3209: * actually need in IssueType.
3210: */
3211: protected List getReportsJoinIssueType(Criteria criteria)
3212: throws TorqueException {
3213: if (collReports == null) {
3214: if (isNew()) {
3215: collReports = new ArrayList();
3216: } else {
3217: criteria
3218: .add(ReportPeer.ISSUE_TYPE_ID, getIssueTypeId());
3219: collReports = ReportPeer
3220: .doSelectJoinIssueType(criteria);
3221: }
3222: } else {
3223: // the following code is to determine if a new query is
3224: // called for. If the criteria is the same as the last
3225: // one, just return the collection.
3226: criteria.add(ReportPeer.ISSUE_TYPE_ID, getIssueTypeId());
3227: if (!lastReportsCriteria.equals(criteria)) {
3228: collReports = ReportPeer
3229: .doSelectJoinIssueType(criteria);
3230: }
3231: }
3232: lastReportsCriteria = criteria;
3233:
3234: return collReports;
3235: }
3236:
3237: /**
3238: * If this collection has already been initialized with
3239: * an identical criteria, it returns the collection.
3240: * Otherwise if this IssueType is new, it will return
3241: * an empty collection; or if this IssueType has previously
3242: * been saved, it will retrieve related Reports from storage.
3243: *
3244: * This method is protected by default in order to keep the public
3245: * api reasonable. You can provide public methods for those you
3246: * actually need in IssueType.
3247: */
3248: protected List getReportsJoinScarabUserImpl(Criteria criteria)
3249: throws TorqueException {
3250: if (collReports == null) {
3251: if (isNew()) {
3252: collReports = new ArrayList();
3253: } else {
3254: criteria
3255: .add(ReportPeer.ISSUE_TYPE_ID, getIssueTypeId());
3256: collReports = ReportPeer
3257: .doSelectJoinScarabUserImpl(criteria);
3258: }
3259: } else {
3260: // the following code is to determine if a new query is
3261: // called for. If the criteria is the same as the last
3262: // one, just return the collection.
3263: criteria.add(ReportPeer.ISSUE_TYPE_ID, getIssueTypeId());
3264: if (!lastReportsCriteria.equals(criteria)) {
3265: collReports = ReportPeer
3266: .doSelectJoinScarabUserImpl(criteria);
3267: }
3268: }
3269: lastReportsCriteria = criteria;
3270:
3271: return collReports;
3272: }
3273:
3274: /**
3275: * If this collection has already been initialized with
3276: * an identical criteria, it returns the collection.
3277: * Otherwise if this IssueType is new, it will return
3278: * an empty collection; or if this IssueType has previously
3279: * been saved, it will retrieve related Reports from storage.
3280: *
3281: * This method is protected by default in order to keep the public
3282: * api reasonable. You can provide public methods for those you
3283: * actually need in IssueType.
3284: */
3285: protected List getReportsJoinScarabModule(Criteria criteria)
3286: throws TorqueException {
3287: if (collReports == null) {
3288: if (isNew()) {
3289: collReports = new ArrayList();
3290: } else {
3291: criteria
3292: .add(ReportPeer.ISSUE_TYPE_ID, getIssueTypeId());
3293: collReports = ReportPeer
3294: .doSelectJoinScarabModule(criteria);
3295: }
3296: } else {
3297: // the following code is to determine if a new query is
3298: // called for. If the criteria is the same as the last
3299: // one, just return the collection.
3300: criteria.add(ReportPeer.ISSUE_TYPE_ID, getIssueTypeId());
3301: if (!lastReportsCriteria.equals(criteria)) {
3302: collReports = ReportPeer
3303: .doSelectJoinScarabModule(criteria);
3304: }
3305: }
3306: lastReportsCriteria = criteria;
3307:
3308: return collReports;
3309: }
3310:
3311: /**
3312: * If this collection has already been initialized with
3313: * an identical criteria, it returns the collection.
3314: * Otherwise if this IssueType is new, it will return
3315: * an empty collection; or if this IssueType has previously
3316: * been saved, it will retrieve related Reports from storage.
3317: *
3318: * This method is protected by default in order to keep the public
3319: * api reasonable. You can provide public methods for those you
3320: * actually need in IssueType.
3321: */
3322: protected List getReportsJoinScope(Criteria criteria)
3323: throws TorqueException {
3324: if (collReports == null) {
3325: if (isNew()) {
3326: collReports = new ArrayList();
3327: } else {
3328: criteria
3329: .add(ReportPeer.ISSUE_TYPE_ID, getIssueTypeId());
3330: collReports = ReportPeer.doSelectJoinScope(criteria);
3331: }
3332: } else {
3333: // the following code is to determine if a new query is
3334: // called for. If the criteria is the same as the last
3335: // one, just return the collection.
3336: criteria.add(ReportPeer.ISSUE_TYPE_ID, getIssueTypeId());
3337: if (!lastReportsCriteria.equals(criteria)) {
3338: collReports = ReportPeer.doSelectJoinScope(criteria);
3339: }
3340: }
3341: lastReportsCriteria = criteria;
3342:
3343: return collReports;
3344: }
3345:
3346: private static List fieldNames = null;
3347:
3348: /**
3349: * Generate a list of field names.
3350: *
3351: * @return a list of field names
3352: */
3353: public static synchronized List getFieldNames() {
3354: if (fieldNames == null) {
3355: fieldNames = new ArrayList();
3356: fieldNames.add("IssueTypeId");
3357: fieldNames.add("Name");
3358: fieldNames.add("Description");
3359: fieldNames.add("ParentId");
3360: fieldNames.add("Dedupe");
3361: fieldNames.add("Deleted");
3362: fieldNames.add("Locked");
3363: fieldNames.add("Isdefault");
3364: fieldNames = Collections.unmodifiableList(fieldNames);
3365: }
3366: return fieldNames;
3367: }
3368:
3369: /**
3370: * Retrieves a field from the object by name passed in as a String.
3371: *
3372: * @param name field name
3373: * @return value
3374: */
3375: public Object getByName(String name) {
3376: if (name.equals("IssueTypeId")) {
3377: return getIssueTypeId();
3378: }
3379: if (name.equals("Name")) {
3380: return getName();
3381: }
3382: if (name.equals("Description")) {
3383: return getDescription();
3384: }
3385: if (name.equals("ParentId")) {
3386: return getParentId();
3387: }
3388: if (name.equals("Dedupe")) {
3389: return Boolean.valueOf(getDedupe());
3390: }
3391: if (name.equals("Deleted")) {
3392: return Boolean.valueOf(getDeleted());
3393: }
3394: if (name.equals("Locked")) {
3395: return Boolean.valueOf(getLocked());
3396: }
3397: if (name.equals("Isdefault")) {
3398: return Boolean.valueOf(getIsdefault());
3399: }
3400: return null;
3401: }
3402:
3403: /**
3404: * Retrieves a field from the object by name passed in
3405: * as a String. The String must be one of the static
3406: * Strings defined in this Class' Peer.
3407: *
3408: * @param name peer name
3409: * @return value
3410: */
3411: public Object getByPeerName(String name) {
3412: if (name.equals(IssueTypePeer.ISSUE_TYPE_ID)) {
3413: return getIssueTypeId();
3414: }
3415: if (name.equals(IssueTypePeer.NAME)) {
3416: return getName();
3417: }
3418: if (name.equals(IssueTypePeer.DESCRIPTION)) {
3419: return getDescription();
3420: }
3421: if (name.equals(IssueTypePeer.PARENT_ID)) {
3422: return getParentId();
3423: }
3424: if (name.equals(IssueTypePeer.DEDUPE)) {
3425: return Boolean.valueOf(getDedupe());
3426: }
3427: if (name.equals(IssueTypePeer.DELETED)) {
3428: return Boolean.valueOf(getDeleted());
3429: }
3430: if (name.equals(IssueTypePeer.LOCKED)) {
3431: return Boolean.valueOf(getLocked());
3432: }
3433: if (name.equals(IssueTypePeer.ISDEFAULT)) {
3434: return Boolean.valueOf(getIsdefault());
3435: }
3436: return null;
3437: }
3438:
3439: /**
3440: * Retrieves a field from the object by Position as specified
3441: * in the xml schema. Zero-based.
3442: *
3443: * @param pos position in xml schema
3444: * @return value
3445: */
3446: public Object getByPosition(int pos) {
3447: if (pos == 0) {
3448: return getIssueTypeId();
3449: }
3450: if (pos == 1) {
3451: return getName();
3452: }
3453: if (pos == 2) {
3454: return getDescription();
3455: }
3456: if (pos == 3) {
3457: return getParentId();
3458: }
3459: if (pos == 4) {
3460: return Boolean.valueOf(getDedupe());
3461: }
3462: if (pos == 5) {
3463: return Boolean.valueOf(getDeleted());
3464: }
3465: if (pos == 6) {
3466: return Boolean.valueOf(getLocked());
3467: }
3468: if (pos == 7) {
3469: return Boolean.valueOf(getIsdefault());
3470: }
3471: return null;
3472: }
3473:
3474: /**
3475: * Stores the object in the database. If the object is new,
3476: * it inserts it; otherwise an update is performed.
3477: *
3478: * @throws TorqueException
3479: */
3480: public void save() throws TorqueException {
3481: save(IssueTypePeer.getMapBuilder().getDatabaseMap().getName());
3482: }
3483:
3484: /**
3485: * Stores the object in the database. If the object is new,
3486: * it inserts it; otherwise an update is performed.
3487: * Note: this code is here because the method body is
3488: * auto-generated conditionally and therefore needs to be
3489: * in this file instead of in the super class, BaseObject.
3490: *
3491: * @param dbName
3492: * @throws TorqueException
3493: */
3494: public void save(String dbName) throws TorqueException {
3495: Connection con = null;
3496: try {
3497: con = Transaction.begin(dbName);
3498: save(con);
3499: Transaction.commit(con);
3500: } catch (TorqueException e) {
3501: Transaction.safeRollback(con);
3502: throw e;
3503: }
3504: }
3505:
3506: /** flag to prevent endless save loop, if this object is referenced
3507: by another object which falls in this transaction. */
3508: private boolean alreadyInSave = false;
3509:
3510: /**
3511: * Stores the object in the database. If the object is new,
3512: * it inserts it; otherwise an update is performed. This method
3513: * is meant to be used as part of a transaction, otherwise use
3514: * the save() method and the connection details will be handled
3515: * internally
3516: *
3517: * @param con
3518: * @throws TorqueException
3519: */
3520: public void save(Connection con) throws TorqueException {
3521: if (!alreadyInSave) {
3522: alreadyInSave = true;
3523:
3524: // If this object has been modified, then save it to the database.
3525: if (isModified()) {
3526: if (isNew()) {
3527: IssueTypePeer.doInsert((IssueType) this , con);
3528: setNew(false);
3529: } else {
3530: IssueTypePeer.doUpdate((IssueType) this , con);
3531: }
3532:
3533: if (isCacheOnSave()) {
3534: IssueTypeManager.putInstance(this );
3535: }
3536: }
3537:
3538: if (collAttributeGroups != null) {
3539: for (int i = 0; i < collAttributeGroups.size(); i++) {
3540: ((AttributeGroup) collAttributeGroups.get(i))
3541: .save(con);
3542: }
3543: }
3544:
3545: if (collIssues != null) {
3546: for (int i = 0; i < collIssues.size(); i++) {
3547: ((Issue) collIssues.get(i)).save(con);
3548: }
3549: }
3550:
3551: if (collRModuleIssueTypes != null) {
3552: for (int i = 0; i < collRModuleIssueTypes.size(); i++) {
3553: ((RModuleIssueType) collRModuleIssueTypes.get(i))
3554: .save(con);
3555: }
3556: }
3557:
3558: if (collMITListItems != null) {
3559: for (int i = 0; i < collMITListItems.size(); i++) {
3560: ((MITListItem) collMITListItems.get(i)).save(con);
3561: }
3562: }
3563:
3564: if (collRModuleAttributes != null) {
3565: for (int i = 0; i < collRModuleAttributes.size(); i++) {
3566: ((RModuleAttribute) collRModuleAttributes.get(i))
3567: .save(con);
3568: }
3569: }
3570:
3571: if (collRIssueTypeAttributes != null) {
3572: for (int i = 0; i < collRIssueTypeAttributes.size(); i++) {
3573: ((RIssueTypeAttribute) collRIssueTypeAttributes
3574: .get(i)).save(con);
3575: }
3576: }
3577:
3578: if (collRModuleOptions != null) {
3579: for (int i = 0; i < collRModuleOptions.size(); i++) {
3580: ((RModuleOption) collRModuleOptions.get(i))
3581: .save(con);
3582: }
3583: }
3584:
3585: if (collRIssueTypeOptions != null) {
3586: for (int i = 0; i < collRIssueTypeOptions.size(); i++) {
3587: ((RIssueTypeOption) collRIssueTypeOptions.get(i))
3588: .save(con);
3589: }
3590: }
3591:
3592: if (collRModuleUserAttributes != null) {
3593: for (int i = 0; i < collRModuleUserAttributes.size(); i++) {
3594: ((RModuleUserAttribute) collRModuleUserAttributes
3595: .get(i)).save(con);
3596: }
3597: }
3598:
3599: if (collQuerys != null) {
3600: for (int i = 0; i < collQuerys.size(); i++) {
3601: ((Query) collQuerys.get(i)).save(con);
3602: }
3603: }
3604:
3605: if (collReports != null) {
3606: for (int i = 0; i < collReports.size(); i++) {
3607: ((Report) collReports.get(i)).save(con);
3608: }
3609: }
3610: alreadyInSave = false;
3611: }
3612: }
3613:
3614: /**
3615: * Specify whether to cache the object after saving to the db.
3616: * This method returns true
3617: */
3618: protected boolean isCacheOnSave() {
3619: return true;
3620: }
3621:
3622: /**
3623: * Set the PrimaryKey using ObjectKey.
3624: *
3625: * @param key issueTypeId ObjectKey
3626: */
3627: public void setPrimaryKey(ObjectKey key) throws TorqueException {
3628: setIssueTypeId(new Integer(((NumberKey) key).intValue()));
3629: }
3630:
3631: /**
3632: * Set the PrimaryKey using a String.
3633: *
3634: * @param key
3635: */
3636: public void setPrimaryKey(String key) throws TorqueException {
3637: setIssueTypeId(new Integer(key));
3638: }
3639:
3640: /**
3641: * returns an id that differentiates this object from others
3642: * of its class.
3643: */
3644: public ObjectKey getPrimaryKey() {
3645: return SimpleKey.keyFor(getIssueTypeId());
3646: }
3647:
3648: /**
3649: * get an id that differentiates this object from others
3650: * of its class.
3651: */
3652: public String getQueryKey() {
3653: if (getPrimaryKey() == null) {
3654: return "";
3655: } else {
3656: return getPrimaryKey().toString();
3657: }
3658: }
3659:
3660: /**
3661: * set an id that differentiates this object from others
3662: * of its class.
3663: */
3664: public void setQueryKey(String key) throws TorqueException {
3665: setPrimaryKey(key);
3666: }
3667:
3668: /**
3669: * Makes a copy of this object.
3670: * It creates a new object filling in the simple attributes.
3671: * It then fills all the association collections and sets the
3672: * related objects to isNew=true.
3673: */
3674: public IssueType copy() throws TorqueException {
3675: return copyInto(new IssueType());
3676: }
3677:
3678: protected IssueType copyInto(IssueType copyObj)
3679: throws TorqueException {
3680: copyObj.setIssueTypeId(issueTypeId);
3681: copyObj.setName(name);
3682: copyObj.setDescription(description);
3683: copyObj.setParentId(parentId);
3684: copyObj.setDedupe(dedupe);
3685: copyObj.setDeleted(deleted);
3686: copyObj.setLocked(locked);
3687: copyObj.setIsdefault(isdefault);
3688:
3689: copyObj.setIssueTypeId((Integer) null);
3690:
3691: List v = getAttributeGroups();
3692: if (v != null) {
3693: for (int i = 0; i < v.size(); i++) {
3694: AttributeGroup obj = (AttributeGroup) v.get(i);
3695: copyObj.addAttributeGroup(obj.copy());
3696: }
3697: } else {
3698: copyObj.collAttributeGroups = null;
3699: }
3700:
3701: v = getIssues();
3702: if (v != null) {
3703: for (int i = 0; i < v.size(); i++) {
3704: Issue obj = (Issue) v.get(i);
3705: copyObj.addIssue(obj.copy());
3706: }
3707: } else {
3708: copyObj.collIssues = null;
3709: }
3710:
3711: v = getRModuleIssueTypes();
3712: if (v != null) {
3713: for (int i = 0; i < v.size(); i++) {
3714: RModuleIssueType obj = (RModuleIssueType) v.get(i);
3715: copyObj.addRModuleIssueType(obj.copy());
3716: }
3717: } else {
3718: copyObj.collRModuleIssueTypes = null;
3719: }
3720:
3721: v = getMITListItems();
3722: if (v != null) {
3723: for (int i = 0; i < v.size(); i++) {
3724: MITListItem obj = (MITListItem) v.get(i);
3725: copyObj.addMITListItem(obj.copy());
3726: }
3727: } else {
3728: copyObj.collMITListItems = null;
3729: }
3730:
3731: v = getRModuleAttributes();
3732: if (v != null) {
3733: for (int i = 0; i < v.size(); i++) {
3734: RModuleAttribute obj = (RModuleAttribute) v.get(i);
3735: copyObj.addRModuleAttribute(obj.copy());
3736: }
3737: } else {
3738: copyObj.collRModuleAttributes = null;
3739: }
3740:
3741: v = getRIssueTypeAttributes();
3742: if (v != null) {
3743: for (int i = 0; i < v.size(); i++) {
3744: RIssueTypeAttribute obj = (RIssueTypeAttribute) v
3745: .get(i);
3746: copyObj.addRIssueTypeAttribute(obj.copy());
3747: }
3748: } else {
3749: copyObj.collRIssueTypeAttributes = null;
3750: }
3751:
3752: v = getRModuleOptions();
3753: if (v != null) {
3754: for (int i = 0; i < v.size(); i++) {
3755: RModuleOption obj = (RModuleOption) v.get(i);
3756: copyObj.addRModuleOption(obj.copy());
3757: }
3758: } else {
3759: copyObj.collRModuleOptions = null;
3760: }
3761:
3762: v = getRIssueTypeOptions();
3763: if (v != null) {
3764: for (int i = 0; i < v.size(); i++) {
3765: RIssueTypeOption obj = (RIssueTypeOption) v.get(i);
3766: copyObj.addRIssueTypeOption(obj.copy());
3767: }
3768: } else {
3769: copyObj.collRIssueTypeOptions = null;
3770: }
3771:
3772: v = getRModuleUserAttributes();
3773: if (v != null) {
3774: for (int i = 0; i < v.size(); i++) {
3775: RModuleUserAttribute obj = (RModuleUserAttribute) v
3776: .get(i);
3777: copyObj.addRModuleUserAttribute(obj.copy());
3778: }
3779: } else {
3780: copyObj.collRModuleUserAttributes = null;
3781: }
3782:
3783: v = getQuerys();
3784: if (v != null) {
3785: for (int i = 0; i < v.size(); i++) {
3786: Query obj = (Query) v.get(i);
3787: copyObj.addQuery(obj.copy());
3788: }
3789: } else {
3790: copyObj.collQuerys = null;
3791: }
3792:
3793: v = getReports();
3794: if (v != null) {
3795: for (int i = 0; i < v.size(); i++) {
3796: Report obj = (Report) v.get(i);
3797: copyObj.addReport(obj.copy());
3798: }
3799: } else {
3800: copyObj.collReports = null;
3801: }
3802: return copyObj;
3803: }
3804:
3805: /**
3806: * returns a peer instance associated with this om. Since Peer classes
3807: * are not to have any instance attributes, this method returns the
3808: * same instance for all member of this class. The method could therefore
3809: * be static, but this would prevent one from overriding the behavior.
3810: */
3811: public IssueTypePeer getPeer() {
3812: return peer;
3813: }
3814:
3815: public String toString() {
3816: StringBuffer str = new StringBuffer();
3817: str.append("IssueType:\n");
3818: str.append("IssueTypeId = ").append(getIssueTypeId()).append(
3819: "\n");
3820: str.append("Name = ").append(getName()).append("\n");
3821: str.append("Description = ").append(getDescription()).append(
3822: "\n");
3823: str.append("ParentId = ").append(getParentId()).append("\n");
3824: str.append("Dedupe = ").append(getDedupe()).append("\n");
3825: str.append("Deleted = ").append(getDeleted()).append("\n");
3826: str.append("Locked = ").append(getLocked()).append("\n");
3827: str.append("Isdefault = ").append(getIsdefault()).append("\n");
3828: return (str.toString());
3829: }
3830: }
|