0001: /*
0002: * <copyright>
0003: *
0004: * Copyright 1997-2004 BBNT Solutions, LLC
0005: * under sponsorship of the Defense Advanced Research Projects
0006: * Agency (DARPA).
0007: *
0008: * You can redistribute this software and/or modify it under the
0009: * terms of the Cougaar Open Source License as published on the
0010: * Cougaar Open Source Website (www.cougaar.org).
0011: *
0012: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
0013: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
0014: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
0015: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
0016: * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
0017: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
0018: * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
0019: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
0020: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
0021: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
0022: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
0023: *
0024: * </copyright>
0025: */
0026:
0027: /* @generated Thu Sep 27 15:21:47 EDT 2007 from /u01/builds/cougaar/B12_4/B12_4/070927151721/src/glm/src/org/cougaar/glm/ldm/asset/alpprops.def - DO NOT HAND EDIT */
0028: /** Abstract Asset Skeleton implementation
0029: * Implements default property getters, and additional property
0030: * lists.
0031: * Intended to be extended by org.cougaar.planning.ldm.asset.Asset
0032: **/package org.cougaar.glm.ldm.asset;
0033:
0034: import org.cougaar.planning.ldm.measure.*;
0035: import org.cougaar.planning.ldm.asset.*;
0036: import org.cougaar.planning.ldm.plan.*;
0037: import java.util.*;
0038:
0039: import org.cougaar.glm.ldm.plan.*;
0040: import org.cougaar.glm.ldm.oplan.*;
0041: import org.cougaar.glm.ldm.policy.*;
0042: import org.cougaar.core.mts.MessageAddress;
0043: import org.cougaar.glm.execution.common.InventoryReport;
0044:
0045: import java.io.Serializable;
0046: import java.beans.PropertyDescriptor;
0047: import java.beans.IndexedPropertyDescriptor;
0048:
0049: public abstract class AssetSkeleton extends
0050: org.cougaar.planning.ldm.asset.Asset {
0051:
0052: protected AssetSkeleton() {
0053: }
0054:
0055: protected AssetSkeleton(AssetSkeleton prototype) {
0056: super (prototype);
0057: }
0058:
0059: /** Default PG accessors **/
0060:
0061: /** Search additional properties for a RepairDepotPG instance.
0062: * @return instance of RepairDepotPG or null.
0063: **/
0064: public RepairDepotPG getRepairDepotPG() {
0065: RepairDepotPG _tmp = (RepairDepotPG) resolvePG(RepairDepotPG.class);
0066: return (_tmp == RepairDepotPG.nullPG) ? null : _tmp;
0067: }
0068:
0069: /** Test for existence of a RepairDepotPG
0070: **/
0071: public boolean hasRepairDepotPG() {
0072: return (getRepairDepotPG() != null);
0073: }
0074:
0075: /** Set the RepairDepotPG property.
0076: * The default implementation will create a new RepairDepotPG
0077: * property and add it to the otherPropertyGroup list.
0078: * Many subclasses override with local slots.
0079: **/
0080: public void setRepairDepotPG(PropertyGroup aRepairDepotPG) {
0081: if (aRepairDepotPG == null) {
0082: removeOtherPropertyGroup(RepairDepotPG.class);
0083: } else {
0084: addOtherPropertyGroup(aRepairDepotPG);
0085: }
0086: }
0087:
0088: /** Search additional properties for a ForUnitPG instance.
0089: * @return instance of ForUnitPG or null.
0090: **/
0091: public ForUnitPG getForUnitPG() {
0092: ForUnitPG _tmp = (ForUnitPG) resolvePG(ForUnitPG.class);
0093: return (_tmp == ForUnitPG.nullPG) ? null : _tmp;
0094: }
0095:
0096: /** Test for existence of a ForUnitPG
0097: **/
0098: public boolean hasForUnitPG() {
0099: return (getForUnitPG() != null);
0100: }
0101:
0102: /** Set the ForUnitPG property.
0103: * The default implementation will create a new ForUnitPG
0104: * property and add it to the otherPropertyGroup list.
0105: * Many subclasses override with local slots.
0106: **/
0107: public void setForUnitPG(PropertyGroup aForUnitPG) {
0108: if (aForUnitPG == null) {
0109: removeOtherPropertyGroup(ForUnitPG.class);
0110: } else {
0111: addOtherPropertyGroup(aForUnitPG);
0112: }
0113: }
0114:
0115: /** Search additional properties for a AmmunitionPG instance.
0116: * @return instance of AmmunitionPG or null.
0117: **/
0118: public AmmunitionPG getAmmunitionPG() {
0119: AmmunitionPG _tmp = (AmmunitionPG) resolvePG(AmmunitionPG.class);
0120: return (_tmp == AmmunitionPG.nullPG) ? null : _tmp;
0121: }
0122:
0123: /** Test for existence of a AmmunitionPG
0124: **/
0125: public boolean hasAmmunitionPG() {
0126: return (getAmmunitionPG() != null);
0127: }
0128:
0129: /** Set the AmmunitionPG property.
0130: * The default implementation will create a new AmmunitionPG
0131: * property and add it to the otherPropertyGroup list.
0132: * Many subclasses override with local slots.
0133: **/
0134: public void setAmmunitionPG(PropertyGroup aAmmunitionPG) {
0135: if (aAmmunitionPG == null) {
0136: removeOtherPropertyGroup(AmmunitionPG.class);
0137: } else {
0138: addOtherPropertyGroup(aAmmunitionPG);
0139: }
0140: }
0141:
0142: /** Search additional properties for a SupplyDepotPG instance.
0143: * @return instance of SupplyDepotPG or null.
0144: **/
0145: public SupplyDepotPG getSupplyDepotPG() {
0146: SupplyDepotPG _tmp = (SupplyDepotPG) resolvePG(SupplyDepotPG.class);
0147: return (_tmp == SupplyDepotPG.nullPG) ? null : _tmp;
0148: }
0149:
0150: /** Test for existence of a SupplyDepotPG
0151: **/
0152: public boolean hasSupplyDepotPG() {
0153: return (getSupplyDepotPG() != null);
0154: }
0155:
0156: /** Set the SupplyDepotPG property.
0157: * The default implementation will create a new SupplyDepotPG
0158: * property and add it to the otherPropertyGroup list.
0159: * Many subclasses override with local slots.
0160: **/
0161: public void setSupplyDepotPG(PropertyGroup aSupplyDepotPG) {
0162: if (aSupplyDepotPG == null) {
0163: removeOtherPropertyGroup(SupplyDepotPG.class);
0164: } else {
0165: addOtherPropertyGroup(aSupplyDepotPG);
0166: }
0167: }
0168:
0169: /** Search additional properties for a PositionPG instance.
0170: * @return instance of PositionPG or null.
0171: **/
0172: public PositionPG getPositionPG() {
0173: PositionPG _tmp = (PositionPG) resolvePG(PositionPG.class);
0174: return (_tmp == PositionPG.nullPG) ? null : _tmp;
0175: }
0176:
0177: /** Test for existence of a PositionPG
0178: **/
0179: public boolean hasPositionPG() {
0180: return (getPositionPG() != null);
0181: }
0182:
0183: /** Set the PositionPG property.
0184: * The default implementation will create a new PositionPG
0185: * property and add it to the otherPropertyGroup list.
0186: * Many subclasses override with local slots.
0187: **/
0188: public void setPositionPG(PropertyGroup aPositionPG) {
0189: if (aPositionPG == null) {
0190: removeOtherPropertyGroup(PositionPG.class);
0191: } else {
0192: addOtherPropertyGroup(aPositionPG);
0193: }
0194: }
0195:
0196: /** Search additional properties for a SupplyPG instance.
0197: * @return instance of SupplyPG or null.
0198: **/
0199: public SupplyPG getSupplyPG() {
0200: SupplyPG _tmp = (SupplyPG) resolvePG(SupplyPG.class);
0201: return (_tmp == SupplyPG.nullPG) ? null : _tmp;
0202: }
0203:
0204: /** Test for existence of a SupplyPG
0205: **/
0206: public boolean hasSupplyPG() {
0207: return (getSupplyPG() != null);
0208: }
0209:
0210: /** Set the SupplyPG property.
0211: * The default implementation will create a new SupplyPG
0212: * property and add it to the otherPropertyGroup list.
0213: * Many subclasses override with local slots.
0214: **/
0215: public void setSupplyPG(PropertyGroup aSupplyPG) {
0216: if (aSupplyPG == null) {
0217: removeOtherPropertyGroup(SupplyPG.class);
0218: } else {
0219: addOtherPropertyGroup(aSupplyPG);
0220: }
0221: }
0222:
0223: /** Search additional properties for a AirVehiclePG instance.
0224: * @return instance of AirVehiclePG or null.
0225: **/
0226: public AirVehiclePG getAirVehiclePG() {
0227: AirVehiclePG _tmp = (AirVehiclePG) resolvePG(AirVehiclePG.class);
0228: return (_tmp == AirVehiclePG.nullPG) ? null : _tmp;
0229: }
0230:
0231: /** Test for existence of a AirVehiclePG
0232: **/
0233: public boolean hasAirVehiclePG() {
0234: return (getAirVehiclePG() != null);
0235: }
0236:
0237: /** Set the AirVehiclePG property.
0238: * The default implementation will create a new AirVehiclePG
0239: * property and add it to the otherPropertyGroup list.
0240: * Many subclasses override with local slots.
0241: **/
0242: public void setAirVehiclePG(PropertyGroup aAirVehiclePG) {
0243: if (aAirVehiclePG == null) {
0244: removeOtherPropertyGroup(AirVehiclePG.class);
0245: } else {
0246: addOtherPropertyGroup(aAirVehiclePG);
0247: }
0248: }
0249:
0250: /** Search additional properties for a MaintenancePG instance.
0251: * @return instance of MaintenancePG or null.
0252: **/
0253: public MaintenancePG getMaintenancePG() {
0254: MaintenancePG _tmp = (MaintenancePG) resolvePG(MaintenancePG.class);
0255: return (_tmp == MaintenancePG.nullPG) ? null : _tmp;
0256: }
0257:
0258: /** Test for existence of a MaintenancePG
0259: **/
0260: public boolean hasMaintenancePG() {
0261: return (getMaintenancePG() != null);
0262: }
0263:
0264: /** Set the MaintenancePG property.
0265: * The default implementation will create a new MaintenancePG
0266: * property and add it to the otherPropertyGroup list.
0267: * Many subclasses override with local slots.
0268: **/
0269: public void setMaintenancePG(PropertyGroup aMaintenancePG) {
0270: if (aMaintenancePG == null) {
0271: removeOtherPropertyGroup(MaintenancePG.class);
0272: } else {
0273: addOtherPropertyGroup(aMaintenancePG);
0274: }
0275: }
0276:
0277: /** Search additional properties for a SupportPG instance.
0278: * @return instance of SupportPG or null.
0279: **/
0280: public SupportPG getSupportPG() {
0281: SupportPG _tmp = (SupportPG) resolvePG(SupportPG.class);
0282: return (_tmp == SupportPG.nullPG) ? null : _tmp;
0283: }
0284:
0285: /** Test for existence of a SupportPG
0286: **/
0287: public boolean hasSupportPG() {
0288: return (getSupportPG() != null);
0289: }
0290:
0291: /** Set the SupportPG property.
0292: * The default implementation will create a new SupportPG
0293: * property and add it to the otherPropertyGroup list.
0294: * Many subclasses override with local slots.
0295: **/
0296: public void setSupportPG(PropertyGroup aSupportPG) {
0297: if (aSupportPG == null) {
0298: removeOtherPropertyGroup(SupportPG.class);
0299: } else {
0300: addOtherPropertyGroup(aSupportPG);
0301: }
0302: }
0303:
0304: /** Search additional properties for a AirConditionPG instance.
0305: * @return instance of AirConditionPG or null.
0306: **/
0307: public AirConditionPG getAirConditionPG() {
0308: AirConditionPG _tmp = (AirConditionPG) resolvePG(AirConditionPG.class);
0309: return (_tmp == AirConditionPG.nullPG) ? null : _tmp;
0310: }
0311:
0312: /** Test for existence of a AirConditionPG
0313: **/
0314: public boolean hasAirConditionPG() {
0315: return (getAirConditionPG() != null);
0316: }
0317:
0318: /** Set the AirConditionPG property.
0319: * The default implementation will create a new AirConditionPG
0320: * property and add it to the otherPropertyGroup list.
0321: * Many subclasses override with local slots.
0322: **/
0323: public void setAirConditionPG(PropertyGroup aAirConditionPG) {
0324: if (aAirConditionPG == null) {
0325: removeOtherPropertyGroup(AirConditionPG.class);
0326: } else {
0327: addOtherPropertyGroup(aAirConditionPG);
0328: }
0329: }
0330:
0331: /** Search additional properties for a AssetConsumptionRatePG instance.
0332: * @return instance of AssetConsumptionRatePG or null.
0333: **/
0334: public AssetConsumptionRatePG getAssetConsumptionRatePG() {
0335: AssetConsumptionRatePG _tmp = (AssetConsumptionRatePG) resolvePG(AssetConsumptionRatePG.class);
0336: return (_tmp == AssetConsumptionRatePG.nullPG) ? null : _tmp;
0337: }
0338:
0339: /** Test for existence of a AssetConsumptionRatePG
0340: **/
0341: public boolean hasAssetConsumptionRatePG() {
0342: return (getAssetConsumptionRatePG() != null);
0343: }
0344:
0345: /** Set the AssetConsumptionRatePG property.
0346: * The default implementation will create a new AssetConsumptionRatePG
0347: * property and add it to the otherPropertyGroup list.
0348: * Many subclasses override with local slots.
0349: **/
0350: public void setAssetConsumptionRatePG(
0351: PropertyGroup aAssetConsumptionRatePG) {
0352: if (aAssetConsumptionRatePG == null) {
0353: removeOtherPropertyGroup(AssetConsumptionRatePG.class);
0354: } else {
0355: addOtherPropertyGroup(aAssetConsumptionRatePG);
0356: }
0357: }
0358:
0359: /** Search additional properties for a TowPG instance.
0360: * @return instance of TowPG or null.
0361: **/
0362: public TowPG getTowPG() {
0363: TowPG _tmp = (TowPG) resolvePG(TowPG.class);
0364: return (_tmp == TowPG.nullPG) ? null : _tmp;
0365: }
0366:
0367: /** Test for existence of a TowPG
0368: **/
0369: public boolean hasTowPG() {
0370: return (getTowPG() != null);
0371: }
0372:
0373: /** Set the TowPG property.
0374: * The default implementation will create a new TowPG
0375: * property and add it to the otherPropertyGroup list.
0376: * Many subclasses override with local slots.
0377: **/
0378: public void setTowPG(PropertyGroup aTowPG) {
0379: if (aTowPG == null) {
0380: removeOtherPropertyGroup(TowPG.class);
0381: } else {
0382: addOtherPropertyGroup(aTowPG);
0383: }
0384: }
0385:
0386: /** Search additional properties for a ReportSchedulePG instance.
0387: * @return instance of ReportSchedulePG or null.
0388: **/
0389: public ReportSchedulePG getReportSchedulePG() {
0390: ReportSchedulePG _tmp = (ReportSchedulePG) resolvePG(ReportSchedulePG.class);
0391: return (_tmp == ReportSchedulePG.nullPG) ? null : _tmp;
0392: }
0393:
0394: /** Test for existence of a ReportSchedulePG
0395: **/
0396: public boolean hasReportSchedulePG() {
0397: return (getReportSchedulePG() != null);
0398: }
0399:
0400: /** Set the ReportSchedulePG property.
0401: * The default implementation will create a new ReportSchedulePG
0402: * property and add it to the otherPropertyGroup list.
0403: * Many subclasses override with local slots.
0404: **/
0405: public void setReportSchedulePG(PropertyGroup aReportSchedulePG) {
0406: if (aReportSchedulePG == null) {
0407: removeOtherPropertyGroup(ReportSchedulePG.class);
0408: } else {
0409: addOtherPropertyGroup(aReportSchedulePG);
0410: }
0411: }
0412:
0413: /** Search additional properties for a OnRoadTransportationPG instance.
0414: * @return instance of OnRoadTransportationPG or null.
0415: **/
0416: public OnRoadTransportationPG getOnRoadTransportationPG() {
0417: OnRoadTransportationPG _tmp = (OnRoadTransportationPG) resolvePG(OnRoadTransportationPG.class);
0418: return (_tmp == OnRoadTransportationPG.nullPG) ? null : _tmp;
0419: }
0420:
0421: /** Test for existence of a OnRoadTransportationPG
0422: **/
0423: public boolean hasOnRoadTransportationPG() {
0424: return (getOnRoadTransportationPG() != null);
0425: }
0426:
0427: /** Set the OnRoadTransportationPG property.
0428: * The default implementation will create a new OnRoadTransportationPG
0429: * property and add it to the otherPropertyGroup list.
0430: * Many subclasses override with local slots.
0431: **/
0432: public void setOnRoadTransportationPG(
0433: PropertyGroup aOnRoadTransportationPG) {
0434: if (aOnRoadTransportationPG == null) {
0435: removeOtherPropertyGroup(OnRoadTransportationPG.class);
0436: } else {
0437: addOtherPropertyGroup(aOnRoadTransportationPG);
0438: }
0439: }
0440:
0441: /** Search additional properties for a WarheadPG instance.
0442: * @return instance of WarheadPG or null.
0443: **/
0444: public WarheadPG getWarheadPG() {
0445: WarheadPG _tmp = (WarheadPG) resolvePG(WarheadPG.class);
0446: return (_tmp == WarheadPG.nullPG) ? null : _tmp;
0447: }
0448:
0449: /** Test for existence of a WarheadPG
0450: **/
0451: public boolean hasWarheadPG() {
0452: return (getWarheadPG() != null);
0453: }
0454:
0455: /** Set the WarheadPG property.
0456: * The default implementation will create a new WarheadPG
0457: * property and add it to the otherPropertyGroup list.
0458: * Many subclasses override with local slots.
0459: **/
0460: public void setWarheadPG(PropertyGroup aWarheadPG) {
0461: if (aWarheadPG == null) {
0462: removeOtherPropertyGroup(WarheadPG.class);
0463: } else {
0464: addOtherPropertyGroup(aWarheadPG);
0465: }
0466: }
0467:
0468: /** Search additional properties for a ConsumablePG instance.
0469: * @return instance of ConsumablePG or null.
0470: **/
0471: public ConsumablePG getConsumablePG() {
0472: ConsumablePG _tmp = (ConsumablePG) resolvePG(ConsumablePG.class);
0473: return (_tmp == ConsumablePG.nullPG) ? null : _tmp;
0474: }
0475:
0476: /** Test for existence of a ConsumablePG
0477: **/
0478: public boolean hasConsumablePG() {
0479: return (getConsumablePG() != null);
0480: }
0481:
0482: /** Set the ConsumablePG property.
0483: * The default implementation will create a new ConsumablePG
0484: * property and add it to the otherPropertyGroup list.
0485: * Many subclasses override with local slots.
0486: **/
0487: public void setConsumablePG(PropertyGroup aConsumablePG) {
0488: if (aConsumablePG == null) {
0489: removeOtherPropertyGroup(ConsumablePG.class);
0490: } else {
0491: addOtherPropertyGroup(aConsumablePG);
0492: }
0493: }
0494:
0495: /** Search additional properties for a TruckTerminalPG instance.
0496: * @return instance of TruckTerminalPG or null.
0497: **/
0498: public TruckTerminalPG getTruckTerminalPG() {
0499: TruckTerminalPG _tmp = (TruckTerminalPG) resolvePG(TruckTerminalPG.class);
0500: return (_tmp == TruckTerminalPG.nullPG) ? null : _tmp;
0501: }
0502:
0503: /** Test for existence of a TruckTerminalPG
0504: **/
0505: public boolean hasTruckTerminalPG() {
0506: return (getTruckTerminalPG() != null);
0507: }
0508:
0509: /** Set the TruckTerminalPG property.
0510: * The default implementation will create a new TruckTerminalPG
0511: * property and add it to the otherPropertyGroup list.
0512: * Many subclasses override with local slots.
0513: **/
0514: public void setTruckTerminalPG(PropertyGroup aTruckTerminalPG) {
0515: if (aTruckTerminalPG == null) {
0516: removeOtherPropertyGroup(TruckTerminalPG.class);
0517: } else {
0518: addOtherPropertyGroup(aTruckTerminalPG);
0519: }
0520: }
0521:
0522: /** Search additional properties for a WeaponPG instance.
0523: * @return instance of WeaponPG or null.
0524: **/
0525: public WeaponPG getWeaponPG() {
0526: WeaponPG _tmp = (WeaponPG) resolvePG(WeaponPG.class);
0527: return (_tmp == WeaponPG.nullPG) ? null : _tmp;
0528: }
0529:
0530: /** Test for existence of a WeaponPG
0531: **/
0532: public boolean hasWeaponPG() {
0533: return (getWeaponPG() != null);
0534: }
0535:
0536: /** Set the WeaponPG property.
0537: * The default implementation will create a new WeaponPG
0538: * property and add it to the otherPropertyGroup list.
0539: * Many subclasses override with local slots.
0540: **/
0541: public void setWeaponPG(PropertyGroup aWeaponPG) {
0542: if (aWeaponPG == null) {
0543: removeOtherPropertyGroup(WeaponPG.class);
0544: } else {
0545: addOtherPropertyGroup(aWeaponPG);
0546: }
0547: }
0548:
0549: /** Search additional properties for a RailTerminalPG instance.
0550: * @return instance of RailTerminalPG or null.
0551: **/
0552: public RailTerminalPG getRailTerminalPG() {
0553: RailTerminalPG _tmp = (RailTerminalPG) resolvePG(RailTerminalPG.class);
0554: return (_tmp == RailTerminalPG.nullPG) ? null : _tmp;
0555: }
0556:
0557: /** Test for existence of a RailTerminalPG
0558: **/
0559: public boolean hasRailTerminalPG() {
0560: return (getRailTerminalPG() != null);
0561: }
0562:
0563: /** Set the RailTerminalPG property.
0564: * The default implementation will create a new RailTerminalPG
0565: * property and add it to the otherPropertyGroup list.
0566: * Many subclasses override with local slots.
0567: **/
0568: public void setRailTerminalPG(PropertyGroup aRailTerminalPG) {
0569: if (aRailTerminalPG == null) {
0570: removeOtherPropertyGroup(RailTerminalPG.class);
0571: } else {
0572: addOtherPropertyGroup(aRailTerminalPG);
0573: }
0574: }
0575:
0576: /** Search additional properties for a AirLiftPG instance.
0577: * @return instance of AirLiftPG or null.
0578: **/
0579: public AirLiftPG getAirLiftPG() {
0580: AirLiftPG _tmp = (AirLiftPG) resolvePG(AirLiftPG.class);
0581: return (_tmp == AirLiftPG.nullPG) ? null : _tmp;
0582: }
0583:
0584: /** Test for existence of a AirLiftPG
0585: **/
0586: public boolean hasAirLiftPG() {
0587: return (getAirLiftPG() != null);
0588: }
0589:
0590: /** Set the AirLiftPG property.
0591: * The default implementation will create a new AirLiftPG
0592: * property and add it to the otherPropertyGroup list.
0593: * Many subclasses override with local slots.
0594: **/
0595: public void setAirLiftPG(PropertyGroup aAirLiftPG) {
0596: if (aAirLiftPG == null) {
0597: removeOtherPropertyGroup(AirLiftPG.class);
0598: } else {
0599: addOtherPropertyGroup(aAirLiftPG);
0600: }
0601: }
0602:
0603: /** Search additional properties for a SeaTransportationPG instance.
0604: * @return instance of SeaTransportationPG or null.
0605: **/
0606: public SeaTransportationPG getSeaTransportationPG() {
0607: SeaTransportationPG _tmp = (SeaTransportationPG) resolvePG(SeaTransportationPG.class);
0608: return (_tmp == SeaTransportationPG.nullPG) ? null : _tmp;
0609: }
0610:
0611: /** Test for existence of a SeaTransportationPG
0612: **/
0613: public boolean hasSeaTransportationPG() {
0614: return (getSeaTransportationPG() != null);
0615: }
0616:
0617: /** Set the SeaTransportationPG property.
0618: * The default implementation will create a new SeaTransportationPG
0619: * property and add it to the otherPropertyGroup list.
0620: * Many subclasses override with local slots.
0621: **/
0622: public void setSeaTransportationPG(
0623: PropertyGroup aSeaTransportationPG) {
0624: if (aSeaTransportationPG == null) {
0625: removeOtherPropertyGroup(SeaTransportationPG.class);
0626: } else {
0627: addOtherPropertyGroup(aSeaTransportationPG);
0628: }
0629: }
0630:
0631: /** Search additional properties for a GroundVehiclePG instance.
0632: * @return instance of GroundVehiclePG or null.
0633: **/
0634: public GroundVehiclePG getGroundVehiclePG() {
0635: GroundVehiclePG _tmp = (GroundVehiclePG) resolvePG(GroundVehiclePG.class);
0636: return (_tmp == GroundVehiclePG.nullPG) ? null : _tmp;
0637: }
0638:
0639: /** Test for existence of a GroundVehiclePG
0640: **/
0641: public boolean hasGroundVehiclePG() {
0642: return (getGroundVehiclePG() != null);
0643: }
0644:
0645: /** Set the GroundVehiclePG property.
0646: * The default implementation will create a new GroundVehiclePG
0647: * property and add it to the otherPropertyGroup list.
0648: * Many subclasses override with local slots.
0649: **/
0650: public void setGroundVehiclePG(PropertyGroup aGroundVehiclePG) {
0651: if (aGroundVehiclePG == null) {
0652: removeOtherPropertyGroup(GroundVehiclePG.class);
0653: } else {
0654: addOtherPropertyGroup(aGroundVehiclePG);
0655: }
0656: }
0657:
0658: /** Search additional properties for a VolumetricStockagePG instance.
0659: * @return instance of VolumetricStockagePG or null.
0660: **/
0661: public VolumetricStockagePG getVolumetricStockagePG() {
0662: VolumetricStockagePG _tmp = (VolumetricStockagePG) resolvePG(VolumetricStockagePG.class);
0663: return (_tmp == VolumetricStockagePG.nullPG) ? null : _tmp;
0664: }
0665:
0666: /** Test for existence of a VolumetricStockagePG
0667: **/
0668: public boolean hasVolumetricStockagePG() {
0669: return (getVolumetricStockagePG() != null);
0670: }
0671:
0672: /** Set the VolumetricStockagePG property.
0673: * The default implementation will create a new VolumetricStockagePG
0674: * property and add it to the otherPropertyGroup list.
0675: * Many subclasses override with local slots.
0676: **/
0677: public void setVolumetricStockagePG(
0678: PropertyGroup aVolumetricStockagePG) {
0679: if (aVolumetricStockagePG == null) {
0680: removeOtherPropertyGroup(VolumetricStockagePG.class);
0681: } else {
0682: addOtherPropertyGroup(aVolumetricStockagePG);
0683: }
0684: }
0685:
0686: /** Search additional properties for a DeckPG instance.
0687: * @return instance of DeckPG or null.
0688: **/
0689: public DeckPG getDeckPG() {
0690: DeckPG _tmp = (DeckPG) resolvePG(DeckPG.class);
0691: return (_tmp == DeckPG.nullPG) ? null : _tmp;
0692: }
0693:
0694: /** Test for existence of a DeckPG
0695: **/
0696: public boolean hasDeckPG() {
0697: return (getDeckPG() != null);
0698: }
0699:
0700: /** Set the DeckPG property.
0701: * The default implementation will create a new DeckPG
0702: * property and add it to the otherPropertyGroup list.
0703: * Many subclasses override with local slots.
0704: **/
0705: public void setDeckPG(PropertyGroup aDeckPG) {
0706: if (aDeckPG == null) {
0707: removeOtherPropertyGroup(DeckPG.class);
0708: } else {
0709: addOtherPropertyGroup(aDeckPG);
0710: }
0711: }
0712:
0713: /** Search additional properties for a CSSCapabilityPG instance.
0714: * @return instance of CSSCapabilityPG or null.
0715: **/
0716: public CSSCapabilityPG getCSSCapabilityPG() {
0717: CSSCapabilityPG _tmp = (CSSCapabilityPG) resolvePG(CSSCapabilityPG.class);
0718: return (_tmp == CSSCapabilityPG.nullPG) ? null : _tmp;
0719: }
0720:
0721: /** Test for existence of a CSSCapabilityPG
0722: **/
0723: public boolean hasCSSCapabilityPG() {
0724: return (getCSSCapabilityPG() != null);
0725: }
0726:
0727: /** Set the CSSCapabilityPG property.
0728: * The default implementation will create a new CSSCapabilityPG
0729: * property and add it to the otherPropertyGroup list.
0730: * Many subclasses override with local slots.
0731: **/
0732: public void setCSSCapabilityPG(PropertyGroup aCSSCapabilityPG) {
0733: if (aCSSCapabilityPG == null) {
0734: removeOtherPropertyGroup(CSSCapabilityPG.class);
0735: } else {
0736: addOtherPropertyGroup(aCSSCapabilityPG);
0737: }
0738: }
0739:
0740: /** Search additional properties for a DetailedScheduledContentPG instance.
0741: * @return instance of DetailedScheduledContentPG or null.
0742: **/
0743: public DetailedScheduledContentPG getDetailedScheduledContentPG() {
0744: DetailedScheduledContentPG _tmp = (DetailedScheduledContentPG) resolvePG(DetailedScheduledContentPG.class);
0745: return (_tmp == DetailedScheduledContentPG.nullPG) ? null
0746: : _tmp;
0747: }
0748:
0749: /** Test for existence of a DetailedScheduledContentPG
0750: **/
0751: public boolean hasDetailedScheduledContentPG() {
0752: return (getDetailedScheduledContentPG() != null);
0753: }
0754:
0755: /** Set the DetailedScheduledContentPG property.
0756: * The default implementation will create a new DetailedScheduledContentPG
0757: * property and add it to the otherPropertyGroup list.
0758: * Many subclasses override with local slots.
0759: **/
0760: public void setDetailedScheduledContentPG(
0761: PropertyGroup aDetailedScheduledContentPG) {
0762: if (aDetailedScheduledContentPG == null) {
0763: removeOtherPropertyGroup(DetailedScheduledContentPG.class);
0764: } else {
0765: addOtherPropertyGroup(aDetailedScheduledContentPG);
0766: }
0767: }
0768:
0769: /** Search additional properties for a PersonSustainmentPG instance.
0770: * @return instance of PersonSustainmentPG or null.
0771: **/
0772: public PersonSustainmentPG getPersonSustainmentPG() {
0773: PersonSustainmentPG _tmp = (PersonSustainmentPG) resolvePG(PersonSustainmentPG.class);
0774: return (_tmp == PersonSustainmentPG.nullPG) ? null : _tmp;
0775: }
0776:
0777: /** Test for existence of a PersonSustainmentPG
0778: **/
0779: public boolean hasPersonSustainmentPG() {
0780: return (getPersonSustainmentPG() != null);
0781: }
0782:
0783: /** Set the PersonSustainmentPG property.
0784: * The default implementation will create a new PersonSustainmentPG
0785: * property and add it to the otherPropertyGroup list.
0786: * Many subclasses override with local slots.
0787: **/
0788: public void setPersonSustainmentPG(
0789: PropertyGroup aPersonSustainmentPG) {
0790: if (aPersonSustainmentPG == null) {
0791: removeOtherPropertyGroup(PersonSustainmentPG.class);
0792: } else {
0793: addOtherPropertyGroup(aPersonSustainmentPG);
0794: }
0795: }
0796:
0797: /** Search additional properties for a MilitaryPersonPG instance.
0798: * @return instance of MilitaryPersonPG or null.
0799: **/
0800: public MilitaryPersonPG getMilitaryPersonPG() {
0801: MilitaryPersonPG _tmp = (MilitaryPersonPG) resolvePG(MilitaryPersonPG.class);
0802: return (_tmp == MilitaryPersonPG.nullPG) ? null : _tmp;
0803: }
0804:
0805: /** Test for existence of a MilitaryPersonPG
0806: **/
0807: public boolean hasMilitaryPersonPG() {
0808: return (getMilitaryPersonPG() != null);
0809: }
0810:
0811: /** Set the MilitaryPersonPG property.
0812: * The default implementation will create a new MilitaryPersonPG
0813: * property and add it to the otherPropertyGroup list.
0814: * Many subclasses override with local slots.
0815: **/
0816: public void setMilitaryPersonPG(PropertyGroup aMilitaryPersonPG) {
0817: if (aMilitaryPersonPG == null) {
0818: removeOtherPropertyGroup(MilitaryPersonPG.class);
0819: } else {
0820: addOtherPropertyGroup(aMilitaryPersonPG);
0821: }
0822: }
0823:
0824: /** Search additional properties for a LandConditionPG instance.
0825: * @return instance of LandConditionPG or null.
0826: **/
0827: public LandConditionPG getLandConditionPG() {
0828: LandConditionPG _tmp = (LandConditionPG) resolvePG(LandConditionPG.class);
0829: return (_tmp == LandConditionPG.nullPG) ? null : _tmp;
0830: }
0831:
0832: /** Test for existence of a LandConditionPG
0833: **/
0834: public boolean hasLandConditionPG() {
0835: return (getLandConditionPG() != null);
0836: }
0837:
0838: /** Set the LandConditionPG property.
0839: * The default implementation will create a new LandConditionPG
0840: * property and add it to the otherPropertyGroup list.
0841: * Many subclasses override with local slots.
0842: **/
0843: public void setLandConditionPG(PropertyGroup aLandConditionPG) {
0844: if (aLandConditionPG == null) {
0845: removeOtherPropertyGroup(LandConditionPG.class);
0846: } else {
0847: addOtherPropertyGroup(aLandConditionPG);
0848: }
0849: }
0850:
0851: /** Search additional properties for a RailLinkPG instance.
0852: * @return instance of RailLinkPG or null.
0853: **/
0854: public RailLinkPG getRailLinkPG() {
0855: RailLinkPG _tmp = (RailLinkPG) resolvePG(RailLinkPG.class);
0856: return (_tmp == RailLinkPG.nullPG) ? null : _tmp;
0857: }
0858:
0859: /** Test for existence of a RailLinkPG
0860: **/
0861: public boolean hasRailLinkPG() {
0862: return (getRailLinkPG() != null);
0863: }
0864:
0865: /** Set the RailLinkPG property.
0866: * The default implementation will create a new RailLinkPG
0867: * property and add it to the otherPropertyGroup list.
0868: * Many subclasses override with local slots.
0869: **/
0870: public void setRailLinkPG(PropertyGroup aRailLinkPG) {
0871: if (aRailLinkPG == null) {
0872: removeOtherPropertyGroup(RailLinkPG.class);
0873: } else {
0874: addOtherPropertyGroup(aRailLinkPG);
0875: }
0876: }
0877:
0878: /** Search additional properties for a SeaportPG instance.
0879: * @return instance of SeaportPG or null.
0880: **/
0881: public SeaportPG getSeaportPG() {
0882: SeaportPG _tmp = (SeaportPG) resolvePG(SeaportPG.class);
0883: return (_tmp == SeaportPG.nullPG) ? null : _tmp;
0884: }
0885:
0886: /** Test for existence of a SeaportPG
0887: **/
0888: public boolean hasSeaportPG() {
0889: return (getSeaportPG() != null);
0890: }
0891:
0892: /** Set the SeaportPG property.
0893: * The default implementation will create a new SeaportPG
0894: * property and add it to the otherPropertyGroup list.
0895: * Many subclasses override with local slots.
0896: **/
0897: public void setSeaportPG(PropertyGroup aSeaportPG) {
0898: if (aSeaportPG == null) {
0899: removeOtherPropertyGroup(SeaportPG.class);
0900: } else {
0901: addOtherPropertyGroup(aSeaportPG);
0902: }
0903: }
0904:
0905: /** Search additional properties for a BulkSolidPG instance.
0906: * @return instance of BulkSolidPG or null.
0907: **/
0908: public BulkSolidPG getBulkSolidPG() {
0909: BulkSolidPG _tmp = (BulkSolidPG) resolvePG(BulkSolidPG.class);
0910: return (_tmp == BulkSolidPG.nullPG) ? null : _tmp;
0911: }
0912:
0913: /** Test for existence of a BulkSolidPG
0914: **/
0915: public boolean hasBulkSolidPG() {
0916: return (getBulkSolidPG() != null);
0917: }
0918:
0919: /** Set the BulkSolidPG property.
0920: * The default implementation will create a new BulkSolidPG
0921: * property and add it to the otherPropertyGroup list.
0922: * Many subclasses override with local slots.
0923: **/
0924: public void setBulkSolidPG(PropertyGroup aBulkSolidPG) {
0925: if (aBulkSolidPG == null) {
0926: removeOtherPropertyGroup(BulkSolidPG.class);
0927: } else {
0928: addOtherPropertyGroup(aBulkSolidPG);
0929: }
0930: }
0931:
0932: /** Search additional properties for a ContentsPG instance.
0933: * @return instance of ContentsPG or null.
0934: **/
0935: public ContentsPG getContentsPG() {
0936: ContentsPG _tmp = (ContentsPG) resolvePG(ContentsPG.class);
0937: return (_tmp == ContentsPG.nullPG) ? null : _tmp;
0938: }
0939:
0940: /** Test for existence of a ContentsPG
0941: **/
0942: public boolean hasContentsPG() {
0943: return (getContentsPG() != null);
0944: }
0945:
0946: /** Set the ContentsPG property.
0947: * The default implementation will create a new ContentsPG
0948: * property and add it to the otherPropertyGroup list.
0949: * Many subclasses override with local slots.
0950: **/
0951: public void setContentsPG(PropertyGroup aContentsPG) {
0952: if (aContentsPG == null) {
0953: removeOtherPropertyGroup(ContentsPG.class);
0954: } else {
0955: addOtherPropertyGroup(aContentsPG);
0956: }
0957: }
0958:
0959: /** Search additional properties for a TrainingReadinessPG instance.
0960: * @return instance of TrainingReadinessPG or null.
0961: **/
0962: public TrainingReadinessPG getTrainingReadinessPG() {
0963: TrainingReadinessPG _tmp = (TrainingReadinessPG) resolvePG(TrainingReadinessPG.class);
0964: return (_tmp == TrainingReadinessPG.nullPG) ? null : _tmp;
0965: }
0966:
0967: /** Test for existence of a TrainingReadinessPG
0968: **/
0969: public boolean hasTrainingReadinessPG() {
0970: return (getTrainingReadinessPG() != null);
0971: }
0972:
0973: /** Set the TrainingReadinessPG property.
0974: * The default implementation will create a new TrainingReadinessPG
0975: * property and add it to the otherPropertyGroup list.
0976: * Many subclasses override with local slots.
0977: **/
0978: public void setTrainingReadinessPG(
0979: PropertyGroup aTrainingReadinessPG) {
0980: if (aTrainingReadinessPG == null) {
0981: removeOtherPropertyGroup(TrainingReadinessPG.class);
0982: } else {
0983: addOtherPropertyGroup(aTrainingReadinessPG);
0984: }
0985: }
0986:
0987: /** Search additional properties for a WaterSelfPropulsionPG instance.
0988: * @return instance of WaterSelfPropulsionPG or null.
0989: **/
0990: public WaterSelfPropulsionPG getWaterSelfPropulsionPG() {
0991: WaterSelfPropulsionPG _tmp = (WaterSelfPropulsionPG) resolvePG(WaterSelfPropulsionPG.class);
0992: return (_tmp == WaterSelfPropulsionPG.nullPG) ? null : _tmp;
0993: }
0994:
0995: /** Test for existence of a WaterSelfPropulsionPG
0996: **/
0997: public boolean hasWaterSelfPropulsionPG() {
0998: return (getWaterSelfPropulsionPG() != null);
0999: }
1000:
1001: /** Set the WaterSelfPropulsionPG property.
1002: * The default implementation will create a new WaterSelfPropulsionPG
1003: * property and add it to the otherPropertyGroup list.
1004: * Many subclasses override with local slots.
1005: **/
1006: public void setWaterSelfPropulsionPG(
1007: PropertyGroup aWaterSelfPropulsionPG) {
1008: if (aWaterSelfPropulsionPG == null) {
1009: removeOtherPropertyGroup(WaterSelfPropulsionPG.class);
1010: } else {
1011: addOtherPropertyGroup(aWaterSelfPropulsionPG);
1012: }
1013: }
1014:
1015: /** Search additional properties for a PhysicalPG instance.
1016: * @return instance of PhysicalPG or null.
1017: **/
1018: public PhysicalPG getPhysicalPG() {
1019: PhysicalPG _tmp = (PhysicalPG) resolvePG(PhysicalPG.class);
1020: return (_tmp == PhysicalPG.nullPG) ? null : _tmp;
1021: }
1022:
1023: /** Test for existence of a PhysicalPG
1024: **/
1025: public boolean hasPhysicalPG() {
1026: return (getPhysicalPG() != null);
1027: }
1028:
1029: /** Set the PhysicalPG property.
1030: * The default implementation will create a new PhysicalPG
1031: * property and add it to the otherPropertyGroup list.
1032: * Many subclasses override with local slots.
1033: **/
1034: public void setPhysicalPG(PropertyGroup aPhysicalPG) {
1035: if (aPhysicalPG == null) {
1036: removeOtherPropertyGroup(PhysicalPG.class);
1037: } else {
1038: addOtherPropertyGroup(aPhysicalPG);
1039: }
1040: }
1041:
1042: /** Search additional properties for a AirTransportationPG instance.
1043: * @return instance of AirTransportationPG or null.
1044: **/
1045: public AirTransportationPG getAirTransportationPG() {
1046: AirTransportationPG _tmp = (AirTransportationPG) resolvePG(AirTransportationPG.class);
1047: return (_tmp == AirTransportationPG.nullPG) ? null : _tmp;
1048: }
1049:
1050: /** Test for existence of a AirTransportationPG
1051: **/
1052: public boolean hasAirTransportationPG() {
1053: return (getAirTransportationPG() != null);
1054: }
1055:
1056: /** Set the AirTransportationPG property.
1057: * The default implementation will create a new AirTransportationPG
1058: * property and add it to the otherPropertyGroup list.
1059: * Many subclasses override with local slots.
1060: **/
1061: public void setAirTransportationPG(
1062: PropertyGroup aAirTransportationPG) {
1063: if (aAirTransportationPG == null) {
1064: removeOtherPropertyGroup(AirTransportationPG.class);
1065: } else {
1066: addOtherPropertyGroup(aAirTransportationPG);
1067: }
1068: }
1069:
1070: /** Search additional properties for a ScheduledContentPG instance.
1071: * @return instance of ScheduledContentPG or null.
1072: **/
1073: public ScheduledContentPG getScheduledContentPG() {
1074: ScheduledContentPG _tmp = (ScheduledContentPG) resolvePG(ScheduledContentPG.class);
1075: return (_tmp == ScheduledContentPG.nullPG) ? null : _tmp;
1076: }
1077:
1078: /** Test for existence of a ScheduledContentPG
1079: **/
1080: public boolean hasScheduledContentPG() {
1081: return (getScheduledContentPG() != null);
1082: }
1083:
1084: /** Set the ScheduledContentPG property.
1085: * The default implementation will create a new ScheduledContentPG
1086: * property and add it to the otherPropertyGroup list.
1087: * Many subclasses override with local slots.
1088: **/
1089: public void setScheduledContentPG(PropertyGroup aScheduledContentPG) {
1090: if (aScheduledContentPG == null) {
1091: removeOtherPropertyGroup(ScheduledContentPG.class);
1092: } else {
1093: addOtherPropertyGroup(aScheduledContentPG);
1094: }
1095: }
1096:
1097: /** Search additional properties for a ManagedAssetPG instance.
1098: * @return instance of ManagedAssetPG or null.
1099: **/
1100: public ManagedAssetPG getManagedAssetPG() {
1101: ManagedAssetPG _tmp = (ManagedAssetPG) resolvePG(ManagedAssetPG.class);
1102: return (_tmp == ManagedAssetPG.nullPG) ? null : _tmp;
1103: }
1104:
1105: /** Test for existence of a ManagedAssetPG
1106: **/
1107: public boolean hasManagedAssetPG() {
1108: return (getManagedAssetPG() != null);
1109: }
1110:
1111: /** Set the ManagedAssetPG property.
1112: * The default implementation will create a new ManagedAssetPG
1113: * property and add it to the otherPropertyGroup list.
1114: * Many subclasses override with local slots.
1115: **/
1116: public void setManagedAssetPG(PropertyGroup aManagedAssetPG) {
1117: if (aManagedAssetPG == null) {
1118: removeOtherPropertyGroup(ManagedAssetPG.class);
1119: } else {
1120: addOtherPropertyGroup(aManagedAssetPG);
1121: }
1122: }
1123:
1124: /** Search additional properties for a RepairablePG instance.
1125: * @return instance of RepairablePG or null.
1126: **/
1127: public RepairablePG getRepairablePG() {
1128: RepairablePG _tmp = (RepairablePG) resolvePG(RepairablePG.class);
1129: return (_tmp == RepairablePG.nullPG) ? null : _tmp;
1130: }
1131:
1132: /** Test for existence of a RepairablePG
1133: **/
1134: public boolean hasRepairablePG() {
1135: return (getRepairablePG() != null);
1136: }
1137:
1138: /** Set the RepairablePG property.
1139: * The default implementation will create a new RepairablePG
1140: * property and add it to the otherPropertyGroup list.
1141: * Many subclasses override with local slots.
1142: **/
1143: public void setRepairablePG(PropertyGroup aRepairablePG) {
1144: if (aRepairablePG == null) {
1145: removeOtherPropertyGroup(RepairablePG.class);
1146: } else {
1147: addOtherPropertyGroup(aRepairablePG);
1148: }
1149: }
1150:
1151: /** Search additional properties for a VehiclePropertyGroups instance.
1152: * @return instance of VehiclePropertyGroups or null.
1153: **/
1154: public VehiclePropertyGroups getVehiclePropertyGroups() {
1155: VehiclePropertyGroups _tmp = (VehiclePropertyGroups) resolvePG(VehiclePropertyGroups.class);
1156: return (_tmp == VehiclePropertyGroups.nullPG) ? null : _tmp;
1157: }
1158:
1159: /** Test for existence of a VehiclePropertyGroups
1160: **/
1161: public boolean hasVehiclePropertyGroups() {
1162: return (getVehiclePropertyGroups() != null);
1163: }
1164:
1165: /** Set the VehiclePropertyGroups property.
1166: * The default implementation will create a new VehiclePropertyGroups
1167: * property and add it to the otherPropertyGroup list.
1168: * Many subclasses override with local slots.
1169: **/
1170: public void setVehiclePropertyGroups(
1171: PropertyGroup aVehiclePropertyGroups) {
1172: if (aVehiclePropertyGroups == null) {
1173: removeOtherPropertyGroup(VehiclePropertyGroups.class);
1174: } else {
1175: addOtherPropertyGroup(aVehiclePropertyGroups);
1176: }
1177: }
1178:
1179: /** Search additional properties for a InventoryPG instance.
1180: * @return instance of InventoryPG or null.
1181: **/
1182: public InventoryPG getInventoryPG() {
1183: InventoryPG _tmp = (InventoryPG) resolvePG(InventoryPG.class);
1184: return (_tmp == InventoryPG.nullPG) ? null : _tmp;
1185: }
1186:
1187: /** Test for existence of a InventoryPG
1188: **/
1189: public boolean hasInventoryPG() {
1190: return (getInventoryPG() != null);
1191: }
1192:
1193: /** Set the InventoryPG property.
1194: * The default implementation will create a new InventoryPG
1195: * property and add it to the otherPropertyGroup list.
1196: * Many subclasses override with local slots.
1197: **/
1198: public void setInventoryPG(PropertyGroup aInventoryPG) {
1199: if (aInventoryPG == null) {
1200: removeOtherPropertyGroup(InventoryPG.class);
1201: } else {
1202: addOtherPropertyGroup(aInventoryPG);
1203: }
1204: }
1205:
1206: /** Search additional properties for a CargoFacilityPG instance.
1207: * @return instance of CargoFacilityPG or null.
1208: **/
1209: public CargoFacilityPG getCargoFacilityPG() {
1210: CargoFacilityPG _tmp = (CargoFacilityPG) resolvePG(CargoFacilityPG.class);
1211: return (_tmp == CargoFacilityPG.nullPG) ? null : _tmp;
1212: }
1213:
1214: /** Test for existence of a CargoFacilityPG
1215: **/
1216: public boolean hasCargoFacilityPG() {
1217: return (getCargoFacilityPG() != null);
1218: }
1219:
1220: /** Set the CargoFacilityPG property.
1221: * The default implementation will create a new CargoFacilityPG
1222: * property and add it to the otherPropertyGroup list.
1223: * Many subclasses override with local slots.
1224: **/
1225: public void setCargoFacilityPG(PropertyGroup aCargoFacilityPG) {
1226: if (aCargoFacilityPG == null) {
1227: removeOtherPropertyGroup(CargoFacilityPG.class);
1228: } else {
1229: addOtherPropertyGroup(aCargoFacilityPG);
1230: }
1231: }
1232:
1233: /** Search additional properties for a PersonPG instance.
1234: * @return instance of PersonPG or null.
1235: **/
1236: public PersonPG getPersonPG() {
1237: PersonPG _tmp = (PersonPG) resolvePG(PersonPG.class);
1238: return (_tmp == PersonPG.nullPG) ? null : _tmp;
1239: }
1240:
1241: /** Test for existence of a PersonPG
1242: **/
1243: public boolean hasPersonPG() {
1244: return (getPersonPG() != null);
1245: }
1246:
1247: /** Set the PersonPG property.
1248: * The default implementation will create a new PersonPG
1249: * property and add it to the otherPropertyGroup list.
1250: * Many subclasses override with local slots.
1251: **/
1252: public void setPersonPG(PropertyGroup aPersonPG) {
1253: if (aPersonPG == null) {
1254: removeOtherPropertyGroup(PersonPG.class);
1255: } else {
1256: addOtherPropertyGroup(aPersonPG);
1257: }
1258: }
1259:
1260: /** Search additional properties for a DetailKeyPG instance.
1261: * @return instance of DetailKeyPG or null.
1262: **/
1263: public DetailKeyPG getDetailKeyPG() {
1264: DetailKeyPG _tmp = (DetailKeyPG) resolvePG(DetailKeyPG.class);
1265: return (_tmp == DetailKeyPG.nullPG) ? null : _tmp;
1266: }
1267:
1268: /** Test for existence of a DetailKeyPG
1269: **/
1270: public boolean hasDetailKeyPG() {
1271: return (getDetailKeyPG() != null);
1272: }
1273:
1274: /** Set the DetailKeyPG property.
1275: * The default implementation will create a new DetailKeyPG
1276: * property and add it to the otherPropertyGroup list.
1277: * Many subclasses override with local slots.
1278: **/
1279: public void setDetailKeyPG(PropertyGroup aDetailKeyPG) {
1280: if (aDetailKeyPG == null) {
1281: removeOtherPropertyGroup(DetailKeyPG.class);
1282: } else {
1283: addOtherPropertyGroup(aDetailKeyPG);
1284: }
1285: }
1286:
1287: /** Search additional properties for a ContainPG instance.
1288: * @return instance of ContainPG or null.
1289: **/
1290: public ContainPG getContainPG() {
1291: ContainPG _tmp = (ContainPG) resolvePG(ContainPG.class);
1292: return (_tmp == ContainPG.nullPG) ? null : _tmp;
1293: }
1294:
1295: /** Test for existence of a ContainPG
1296: **/
1297: public boolean hasContainPG() {
1298: return (getContainPG() != null);
1299: }
1300:
1301: /** Set the ContainPG property.
1302: * The default implementation will create a new ContainPG
1303: * property and add it to the otherPropertyGroup list.
1304: * Many subclasses override with local slots.
1305: **/
1306: public void setContainPG(PropertyGroup aContainPG) {
1307: if (aContainPG == null) {
1308: removeOtherPropertyGroup(ContainPG.class);
1309: } else {
1310: addOtherPropertyGroup(aContainPG);
1311: }
1312: }
1313:
1314: /** Search additional properties for a FuelSupplyPG instance.
1315: * @return instance of FuelSupplyPG or null.
1316: **/
1317: public FuelSupplyPG getFuelSupplyPG() {
1318: FuelSupplyPG _tmp = (FuelSupplyPG) resolvePG(FuelSupplyPG.class);
1319: return (_tmp == FuelSupplyPG.nullPG) ? null : _tmp;
1320: }
1321:
1322: /** Test for existence of a FuelSupplyPG
1323: **/
1324: public boolean hasFuelSupplyPG() {
1325: return (getFuelSupplyPG() != null);
1326: }
1327:
1328: /** Set the FuelSupplyPG property.
1329: * The default implementation will create a new FuelSupplyPG
1330: * property and add it to the otherPropertyGroup list.
1331: * Many subclasses override with local slots.
1332: **/
1333: public void setFuelSupplyPG(PropertyGroup aFuelSupplyPG) {
1334: if (aFuelSupplyPG == null) {
1335: removeOtherPropertyGroup(FuelSupplyPG.class);
1336: } else {
1337: addOtherPropertyGroup(aFuelSupplyPG);
1338: }
1339: }
1340:
1341: /** Search additional properties for a SupplyClassPG instance.
1342: * @return instance of SupplyClassPG or null.
1343: **/
1344: public SupplyClassPG getSupplyClassPG() {
1345: SupplyClassPG _tmp = (SupplyClassPG) resolvePG(SupplyClassPG.class);
1346: return (_tmp == SupplyClassPG.nullPG) ? null : _tmp;
1347: }
1348:
1349: /** Test for existence of a SupplyClassPG
1350: **/
1351: public boolean hasSupplyClassPG() {
1352: return (getSupplyClassPG() != null);
1353: }
1354:
1355: /** Set the SupplyClassPG property.
1356: * The default implementation will create a new SupplyClassPG
1357: * property and add it to the otherPropertyGroup list.
1358: * Many subclasses override with local slots.
1359: **/
1360: public void setSupplyClassPG(PropertyGroup aSupplyClassPG) {
1361: if (aSupplyClassPG == null) {
1362: removeOtherPropertyGroup(SupplyClassPG.class);
1363: } else {
1364: addOtherPropertyGroup(aSupplyClassPG);
1365: }
1366: }
1367:
1368: /** Search additional properties for a FacilityPG instance.
1369: * @return instance of FacilityPG or null.
1370: **/
1371: public FacilityPG getFacilityPG() {
1372: FacilityPG _tmp = (FacilityPG) resolvePG(FacilityPG.class);
1373: return (_tmp == FacilityPG.nullPG) ? null : _tmp;
1374: }
1375:
1376: /** Test for existence of a FacilityPG
1377: **/
1378: public boolean hasFacilityPG() {
1379: return (getFacilityPG() != null);
1380: }
1381:
1382: /** Set the FacilityPG property.
1383: * The default implementation will create a new FacilityPG
1384: * property and add it to the otherPropertyGroup list.
1385: * Many subclasses override with local slots.
1386: **/
1387: public void setFacilityPG(PropertyGroup aFacilityPG) {
1388: if (aFacilityPG == null) {
1389: removeOtherPropertyGroup(FacilityPG.class);
1390: } else {
1391: addOtherPropertyGroup(aFacilityPG);
1392: }
1393: }
1394:
1395: /** Search additional properties for a InventoryLevelsPG instance.
1396: * @return instance of InventoryLevelsPG or null.
1397: **/
1398: public InventoryLevelsPG getInventoryLevelsPG() {
1399: InventoryLevelsPG _tmp = (InventoryLevelsPG) resolvePG(InventoryLevelsPG.class);
1400: return (_tmp == InventoryLevelsPG.nullPG) ? null : _tmp;
1401: }
1402:
1403: /** Test for existence of a InventoryLevelsPG
1404: **/
1405: public boolean hasInventoryLevelsPG() {
1406: return (getInventoryLevelsPG() != null);
1407: }
1408:
1409: /** Set the InventoryLevelsPG property.
1410: * The default implementation will create a new InventoryLevelsPG
1411: * property and add it to the otherPropertyGroup list.
1412: * Many subclasses override with local slots.
1413: **/
1414: public void setInventoryLevelsPG(PropertyGroup aInventoryLevelsPG) {
1415: if (aInventoryLevelsPG == null) {
1416: removeOtherPropertyGroup(InventoryLevelsPG.class);
1417: } else {
1418: addOtherPropertyGroup(aInventoryLevelsPG);
1419: }
1420: }
1421:
1422: /** Search additional properties for a RailVehiclePG instance.
1423: * @return instance of RailVehiclePG or null.
1424: **/
1425: public RailVehiclePG getRailVehiclePG() {
1426: RailVehiclePG _tmp = (RailVehiclePG) resolvePG(RailVehiclePG.class);
1427: return (_tmp == RailVehiclePG.nullPG) ? null : _tmp;
1428: }
1429:
1430: /** Test for existence of a RailVehiclePG
1431: **/
1432: public boolean hasRailVehiclePG() {
1433: return (getRailVehiclePG() != null);
1434: }
1435:
1436: /** Set the RailVehiclePG property.
1437: * The default implementation will create a new RailVehiclePG
1438: * property and add it to the otherPropertyGroup list.
1439: * Many subclasses override with local slots.
1440: **/
1441: public void setRailVehiclePG(PropertyGroup aRailVehiclePG) {
1442: if (aRailVehiclePG == null) {
1443: removeOtherPropertyGroup(RailVehiclePG.class);
1444: } else {
1445: addOtherPropertyGroup(aRailVehiclePG);
1446: }
1447: }
1448:
1449: /** Search additional properties for a MidAirRefuelPG instance.
1450: * @return instance of MidAirRefuelPG or null.
1451: **/
1452: public MidAirRefuelPG getMidAirRefuelPG() {
1453: MidAirRefuelPG _tmp = (MidAirRefuelPG) resolvePG(MidAirRefuelPG.class);
1454: return (_tmp == MidAirRefuelPG.nullPG) ? null : _tmp;
1455: }
1456:
1457: /** Test for existence of a MidAirRefuelPG
1458: **/
1459: public boolean hasMidAirRefuelPG() {
1460: return (getMidAirRefuelPG() != null);
1461: }
1462:
1463: /** Set the MidAirRefuelPG property.
1464: * The default implementation will create a new MidAirRefuelPG
1465: * property and add it to the otherPropertyGroup list.
1466: * Many subclasses override with local slots.
1467: **/
1468: public void setMidAirRefuelPG(PropertyGroup aMidAirRefuelPG) {
1469: if (aMidAirRefuelPG == null) {
1470: removeOtherPropertyGroup(MidAirRefuelPG.class);
1471: } else {
1472: addOtherPropertyGroup(aMidAirRefuelPG);
1473: }
1474: }
1475:
1476: /** Search additional properties for a FromBasePG instance.
1477: * @return instance of FromBasePG or null.
1478: **/
1479: public FromBasePG getFromBasePG() {
1480: FromBasePG _tmp = (FromBasePG) resolvePG(FromBasePG.class);
1481: return (_tmp == FromBasePG.nullPG) ? null : _tmp;
1482: }
1483:
1484: /** Test for existence of a FromBasePG
1485: **/
1486: public boolean hasFromBasePG() {
1487: return (getFromBasePG() != null);
1488: }
1489:
1490: /** Set the FromBasePG property.
1491: * The default implementation will create a new FromBasePG
1492: * property and add it to the otherPropertyGroup list.
1493: * Many subclasses override with local slots.
1494: **/
1495: public void setFromBasePG(PropertyGroup aFromBasePG) {
1496: if (aFromBasePG == null) {
1497: removeOtherPropertyGroup(FromBasePG.class);
1498: } else {
1499: addOtherPropertyGroup(aFromBasePG);
1500: }
1501: }
1502:
1503: /** Search additional properties for a GroundSelfPropulsionPG instance.
1504: * @return instance of GroundSelfPropulsionPG or null.
1505: **/
1506: public GroundSelfPropulsionPG getGroundSelfPropulsionPG() {
1507: GroundSelfPropulsionPG _tmp = (GroundSelfPropulsionPG) resolvePG(GroundSelfPropulsionPG.class);
1508: return (_tmp == GroundSelfPropulsionPG.nullPG) ? null : _tmp;
1509: }
1510:
1511: /** Test for existence of a GroundSelfPropulsionPG
1512: **/
1513: public boolean hasGroundSelfPropulsionPG() {
1514: return (getGroundSelfPropulsionPG() != null);
1515: }
1516:
1517: /** Set the GroundSelfPropulsionPG property.
1518: * The default implementation will create a new GroundSelfPropulsionPG
1519: * property and add it to the otherPropertyGroup list.
1520: * Many subclasses override with local slots.
1521: **/
1522: public void setGroundSelfPropulsionPG(
1523: PropertyGroup aGroundSelfPropulsionPG) {
1524: if (aGroundSelfPropulsionPG == null) {
1525: removeOtherPropertyGroup(GroundSelfPropulsionPG.class);
1526: } else {
1527: addOtherPropertyGroup(aGroundSelfPropulsionPG);
1528: }
1529: }
1530:
1531: /** Search additional properties for a SeaLinkPG instance.
1532: * @return instance of SeaLinkPG or null.
1533: **/
1534: public SeaLinkPG getSeaLinkPG() {
1535: SeaLinkPG _tmp = (SeaLinkPG) resolvePG(SeaLinkPG.class);
1536: return (_tmp == SeaLinkPG.nullPG) ? null : _tmp;
1537: }
1538:
1539: /** Test for existence of a SeaLinkPG
1540: **/
1541: public boolean hasSeaLinkPG() {
1542: return (getSeaLinkPG() != null);
1543: }
1544:
1545: /** Set the SeaLinkPG property.
1546: * The default implementation will create a new SeaLinkPG
1547: * property and add it to the otherPropertyGroup list.
1548: * Many subclasses override with local slots.
1549: **/
1550: public void setSeaLinkPG(PropertyGroup aSeaLinkPG) {
1551: if (aSeaLinkPG == null) {
1552: removeOtherPropertyGroup(SeaLinkPG.class);
1553: } else {
1554: addOtherPropertyGroup(aSeaLinkPG);
1555: }
1556: }
1557:
1558: /** Search additional properties for a RailSelfPropulsionPG instance.
1559: * @return instance of RailSelfPropulsionPG or null.
1560: **/
1561: public RailSelfPropulsionPG getRailSelfPropulsionPG() {
1562: RailSelfPropulsionPG _tmp = (RailSelfPropulsionPG) resolvePG(RailSelfPropulsionPG.class);
1563: return (_tmp == RailSelfPropulsionPG.nullPG) ? null : _tmp;
1564: }
1565:
1566: /** Test for existence of a RailSelfPropulsionPG
1567: **/
1568: public boolean hasRailSelfPropulsionPG() {
1569: return (getRailSelfPropulsionPG() != null);
1570: }
1571:
1572: /** Set the RailSelfPropulsionPG property.
1573: * The default implementation will create a new RailSelfPropulsionPG
1574: * property and add it to the otherPropertyGroup list.
1575: * Many subclasses override with local slots.
1576: **/
1577: public void setRailSelfPropulsionPG(
1578: PropertyGroup aRailSelfPropulsionPG) {
1579: if (aRailSelfPropulsionPG == null) {
1580: removeOtherPropertyGroup(RailSelfPropulsionPG.class);
1581: } else {
1582: addOtherPropertyGroup(aRailSelfPropulsionPG);
1583: }
1584: }
1585:
1586: /** Search additional properties for a RailTransportationPG instance.
1587: * @return instance of RailTransportationPG or null.
1588: **/
1589: public RailTransportationPG getRailTransportationPG() {
1590: RailTransportationPG _tmp = (RailTransportationPG) resolvePG(RailTransportationPG.class);
1591: return (_tmp == RailTransportationPG.nullPG) ? null : _tmp;
1592: }
1593:
1594: /** Test for existence of a RailTransportationPG
1595: **/
1596: public boolean hasRailTransportationPG() {
1597: return (getRailTransportationPG() != null);
1598: }
1599:
1600: /** Set the RailTransportationPG property.
1601: * The default implementation will create a new RailTransportationPG
1602: * property and add it to the otherPropertyGroup list.
1603: * Many subclasses override with local slots.
1604: **/
1605: public void setRailTransportationPG(
1606: PropertyGroup aRailTransportationPG) {
1607: if (aRailTransportationPG == null) {
1608: removeOtherPropertyGroup(RailTransportationPG.class);
1609: } else {
1610: addOtherPropertyGroup(aRailTransportationPG);
1611: }
1612: }
1613:
1614: /** Search additional properties for a WaterVehiclePG instance.
1615: * @return instance of WaterVehiclePG or null.
1616: **/
1617: public WaterVehiclePG getWaterVehiclePG() {
1618: WaterVehiclePG _tmp = (WaterVehiclePG) resolvePG(WaterVehiclePG.class);
1619: return (_tmp == WaterVehiclePG.nullPG) ? null : _tmp;
1620: }
1621:
1622: /** Test for existence of a WaterVehiclePG
1623: **/
1624: public boolean hasWaterVehiclePG() {
1625: return (getWaterVehiclePG() != null);
1626: }
1627:
1628: /** Set the WaterVehiclePG property.
1629: * The default implementation will create a new WaterVehiclePG
1630: * property and add it to the otherPropertyGroup list.
1631: * Many subclasses override with local slots.
1632: **/
1633: public void setWaterVehiclePG(PropertyGroup aWaterVehiclePG) {
1634: if (aWaterVehiclePG == null) {
1635: removeOtherPropertyGroup(WaterVehiclePG.class);
1636: } else {
1637: addOtherPropertyGroup(aWaterVehiclePG);
1638: }
1639: }
1640:
1641: /** Search additional properties for a FuelPG instance.
1642: * @return instance of FuelPG or null.
1643: **/
1644: public FuelPG getFuelPG() {
1645: FuelPG _tmp = (FuelPG) resolvePG(FuelPG.class);
1646: return (_tmp == FuelPG.nullPG) ? null : _tmp;
1647: }
1648:
1649: /** Test for existence of a FuelPG
1650: **/
1651: public boolean hasFuelPG() {
1652: return (getFuelPG() != null);
1653: }
1654:
1655: /** Set the FuelPG property.
1656: * The default implementation will create a new FuelPG
1657: * property and add it to the otherPropertyGroup list.
1658: * Many subclasses override with local slots.
1659: **/
1660: public void setFuelPG(PropertyGroup aFuelPG) {
1661: if (aFuelPG == null) {
1662: removeOtherPropertyGroup(FuelPG.class);
1663: } else {
1664: addOtherPropertyGroup(aFuelPG);
1665: }
1666: }
1667:
1668: /** Search additional properties for a MovabilityPG instance.
1669: * @return instance of MovabilityPG or null.
1670: **/
1671: public MovabilityPG getMovabilityPG() {
1672: MovabilityPG _tmp = (MovabilityPG) resolvePG(MovabilityPG.class);
1673: return (_tmp == MovabilityPG.nullPG) ? null : _tmp;
1674: }
1675:
1676: /** Test for existence of a MovabilityPG
1677: **/
1678: public boolean hasMovabilityPG() {
1679: return (getMovabilityPG() != null);
1680: }
1681:
1682: /** Set the MovabilityPG property.
1683: * The default implementation will create a new MovabilityPG
1684: * property and add it to the otherPropertyGroup list.
1685: * Many subclasses override with local slots.
1686: **/
1687: public void setMovabilityPG(PropertyGroup aMovabilityPG) {
1688: if (aMovabilityPG == null) {
1689: removeOtherPropertyGroup(MovabilityPG.class);
1690: } else {
1691: addOtherPropertyGroup(aMovabilityPG);
1692: }
1693: }
1694:
1695: /** Search additional properties for a ExplosivePG instance.
1696: * @return instance of ExplosivePG or null.
1697: **/
1698: public ExplosivePG getExplosivePG() {
1699: ExplosivePG _tmp = (ExplosivePG) resolvePG(ExplosivePG.class);
1700: return (_tmp == ExplosivePG.nullPG) ? null : _tmp;
1701: }
1702:
1703: /** Test for existence of a ExplosivePG
1704: **/
1705: public boolean hasExplosivePG() {
1706: return (getExplosivePG() != null);
1707: }
1708:
1709: /** Set the ExplosivePG property.
1710: * The default implementation will create a new ExplosivePG
1711: * property and add it to the otherPropertyGroup list.
1712: * Many subclasses override with local slots.
1713: **/
1714: public void setExplosivePG(PropertyGroup aExplosivePG) {
1715: if (aExplosivePG == null) {
1716: removeOtherPropertyGroup(ExplosivePG.class);
1717: } else {
1718: addOtherPropertyGroup(aExplosivePG);
1719: }
1720: }
1721:
1722: /** Search additional properties for a RoadLinkPG instance.
1723: * @return instance of RoadLinkPG or null.
1724: **/
1725: public RoadLinkPG getRoadLinkPG() {
1726: RoadLinkPG _tmp = (RoadLinkPG) resolvePG(RoadLinkPG.class);
1727: return (_tmp == RoadLinkPG.nullPG) ? null : _tmp;
1728: }
1729:
1730: /** Test for existence of a RoadLinkPG
1731: **/
1732: public boolean hasRoadLinkPG() {
1733: return (getRoadLinkPG() != null);
1734: }
1735:
1736: /** Set the RoadLinkPG property.
1737: * The default implementation will create a new RoadLinkPG
1738: * property and add it to the otherPropertyGroup list.
1739: * Many subclasses override with local slots.
1740: **/
1741: public void setRoadLinkPG(PropertyGroup aRoadLinkPG) {
1742: if (aRoadLinkPG == null) {
1743: removeOtherPropertyGroup(RoadLinkPG.class);
1744: } else {
1745: addOtherPropertyGroup(aRoadLinkPG);
1746: }
1747: }
1748:
1749: /** Search additional properties for a MissileLauncherPG instance.
1750: * @return instance of MissileLauncherPG or null.
1751: **/
1752: public MissileLauncherPG getMissileLauncherPG() {
1753: MissileLauncherPG _tmp = (MissileLauncherPG) resolvePG(MissileLauncherPG.class);
1754: return (_tmp == MissileLauncherPG.nullPG) ? null : _tmp;
1755: }
1756:
1757: /** Test for existence of a MissileLauncherPG
1758: **/
1759: public boolean hasMissileLauncherPG() {
1760: return (getMissileLauncherPG() != null);
1761: }
1762:
1763: /** Set the MissileLauncherPG property.
1764: * The default implementation will create a new MissileLauncherPG
1765: * property and add it to the otherPropertyGroup list.
1766: * Many subclasses override with local slots.
1767: **/
1768: public void setMissileLauncherPG(PropertyGroup aMissileLauncherPG) {
1769: if (aMissileLauncherPG == null) {
1770: removeOtherPropertyGroup(MissileLauncherPG.class);
1771: } else {
1772: addOtherPropertyGroup(aMissileLauncherPG);
1773: }
1774: }
1775:
1776: /** Search additional properties for a AirportPG instance.
1777: * @return instance of AirportPG or null.
1778: **/
1779: public AirportPG getAirportPG() {
1780: AirportPG _tmp = (AirportPG) resolvePG(AirportPG.class);
1781: return (_tmp == AirportPG.nullPG) ? null : _tmp;
1782: }
1783:
1784: /** Test for existence of a AirportPG
1785: **/
1786: public boolean hasAirportPG() {
1787: return (getAirportPG() != null);
1788: }
1789:
1790: /** Set the AirportPG property.
1791: * The default implementation will create a new AirportPG
1792: * property and add it to the otherPropertyGroup list.
1793: * Many subclasses override with local slots.
1794: **/
1795: public void setAirportPG(PropertyGroup aAirportPG) {
1796: if (aAirportPG == null) {
1797: removeOtherPropertyGroup(AirportPG.class);
1798: } else {
1799: addOtherPropertyGroup(aAirportPG);
1800: }
1801: }
1802:
1803: /** Search additional properties for a AssignmentPG instance.
1804: * @return instance of AssignmentPG or null.
1805: **/
1806: public AssignmentPG getAssignmentPG() {
1807: AssignmentPG _tmp = (AssignmentPG) resolvePG(AssignmentPG.class);
1808: return (_tmp == AssignmentPG.nullPG) ? null : _tmp;
1809: }
1810:
1811: /** Test for existence of a AssignmentPG
1812: **/
1813: public boolean hasAssignmentPG() {
1814: return (getAssignmentPG() != null);
1815: }
1816:
1817: /** Set the AssignmentPG property.
1818: * The default implementation will create a new AssignmentPG
1819: * property and add it to the otherPropertyGroup list.
1820: * Many subclasses override with local slots.
1821: **/
1822: public void setAssignmentPG(PropertyGroup aAssignmentPG) {
1823: if (aAssignmentPG == null) {
1824: removeOtherPropertyGroup(AssignmentPG.class);
1825: } else {
1826: addOtherPropertyGroup(aAssignmentPG);
1827: }
1828: }
1829:
1830: /** Search additional properties for a ConditionPG instance.
1831: * @return instance of ConditionPG or null.
1832: **/
1833: public ConditionPG getConditionPG() {
1834: ConditionPG _tmp = (ConditionPG) resolvePG(ConditionPG.class);
1835: return (_tmp == ConditionPG.nullPG) ? null : _tmp;
1836: }
1837:
1838: /** Test for existence of a ConditionPG
1839: **/
1840: public boolean hasConditionPG() {
1841: return (getConditionPG() != null);
1842: }
1843:
1844: /** Set the ConditionPG property.
1845: * The default implementation will create a new ConditionPG
1846: * property and add it to the otherPropertyGroup list.
1847: * Many subclasses override with local slots.
1848: **/
1849: public void setConditionPG(PropertyGroup aConditionPG) {
1850: if (aConditionPG == null) {
1851: removeOtherPropertyGroup(ConditionPG.class);
1852: } else {
1853: addOtherPropertyGroup(aConditionPG);
1854: }
1855: }
1856:
1857: /** Search additional properties for a LiquidPG instance.
1858: * @return instance of LiquidPG or null.
1859: **/
1860: public LiquidPG getLiquidPG() {
1861: LiquidPG _tmp = (LiquidPG) resolvePG(LiquidPG.class);
1862: return (_tmp == LiquidPG.nullPG) ? null : _tmp;
1863: }
1864:
1865: /** Test for existence of a LiquidPG
1866: **/
1867: public boolean hasLiquidPG() {
1868: return (getLiquidPG() != null);
1869: }
1870:
1871: /** Set the LiquidPG property.
1872: * The default implementation will create a new LiquidPG
1873: * property and add it to the otherPropertyGroup list.
1874: * Many subclasses override with local slots.
1875: **/
1876: public void setLiquidPG(PropertyGroup aLiquidPG) {
1877: if (aLiquidPG == null) {
1878: removeOtherPropertyGroup(LiquidPG.class);
1879: } else {
1880: addOtherPropertyGroup(aLiquidPG);
1881: }
1882: }
1883:
1884: /** Search additional properties for a OffRoadTransportationPG instance.
1885: * @return instance of OffRoadTransportationPG or null.
1886: **/
1887: public OffRoadTransportationPG getOffRoadTransportationPG() {
1888: OffRoadTransportationPG _tmp = (OffRoadTransportationPG) resolvePG(OffRoadTransportationPG.class);
1889: return (_tmp == OffRoadTransportationPG.nullPG) ? null : _tmp;
1890: }
1891:
1892: /** Test for existence of a OffRoadTransportationPG
1893: **/
1894: public boolean hasOffRoadTransportationPG() {
1895: return (getOffRoadTransportationPG() != null);
1896: }
1897:
1898: /** Set the OffRoadTransportationPG property.
1899: * The default implementation will create a new OffRoadTransportationPG
1900: * property and add it to the otherPropertyGroup list.
1901: * Many subclasses override with local slots.
1902: **/
1903: public void setOffRoadTransportationPG(
1904: PropertyGroup aOffRoadTransportationPG) {
1905: if (aOffRoadTransportationPG == null) {
1906: removeOtherPropertyGroup(OffRoadTransportationPG.class);
1907: } else {
1908: addOtherPropertyGroup(aOffRoadTransportationPG);
1909: }
1910: }
1911:
1912: /** Search additional properties for a LiftPG instance.
1913: * @return instance of LiftPG or null.
1914: **/
1915: public LiftPG getLiftPG() {
1916: LiftPG _tmp = (LiftPG) resolvePG(LiftPG.class);
1917: return (_tmp == LiftPG.nullPG) ? null : _tmp;
1918: }
1919:
1920: /** Test for existence of a LiftPG
1921: **/
1922: public boolean hasLiftPG() {
1923: return (getLiftPG() != null);
1924: }
1925:
1926: /** Set the LiftPG property.
1927: * The default implementation will create a new LiftPG
1928: * property and add it to the otherPropertyGroup list.
1929: * Many subclasses override with local slots.
1930: **/
1931: public void setLiftPG(PropertyGroup aLiftPG) {
1932: if (aLiftPG == null) {
1933: removeOtherPropertyGroup(LiftPG.class);
1934: } else {
1935: addOtherPropertyGroup(aLiftPG);
1936: }
1937: }
1938:
1939: /** Search additional properties for a PersonnelReadinessPG instance.
1940: * @return instance of PersonnelReadinessPG or null.
1941: **/
1942: public PersonnelReadinessPG getPersonnelReadinessPG() {
1943: PersonnelReadinessPG _tmp = (PersonnelReadinessPG) resolvePG(PersonnelReadinessPG.class);
1944: return (_tmp == PersonnelReadinessPG.nullPG) ? null : _tmp;
1945: }
1946:
1947: /** Test for existence of a PersonnelReadinessPG
1948: **/
1949: public boolean hasPersonnelReadinessPG() {
1950: return (getPersonnelReadinessPG() != null);
1951: }
1952:
1953: /** Set the PersonnelReadinessPG property.
1954: * The default implementation will create a new PersonnelReadinessPG
1955: * property and add it to the otherPropertyGroup list.
1956: * Many subclasses override with local slots.
1957: **/
1958: public void setPersonnelReadinessPG(
1959: PropertyGroup aPersonnelReadinessPG) {
1960: if (aPersonnelReadinessPG == null) {
1961: removeOtherPropertyGroup(PersonnelReadinessPG.class);
1962: } else {
1963: addOtherPropertyGroup(aPersonnelReadinessPG);
1964: }
1965: }
1966:
1967: /** Search additional properties for a EquipmentStatusReadinessPG instance.
1968: * @return instance of EquipmentStatusReadinessPG or null.
1969: **/
1970: public EquipmentStatusReadinessPG getEquipmentStatusReadinessPG() {
1971: EquipmentStatusReadinessPG _tmp = (EquipmentStatusReadinessPG) resolvePG(EquipmentStatusReadinessPG.class);
1972: return (_tmp == EquipmentStatusReadinessPG.nullPG) ? null
1973: : _tmp;
1974: }
1975:
1976: /** Test for existence of a EquipmentStatusReadinessPG
1977: **/
1978: public boolean hasEquipmentStatusReadinessPG() {
1979: return (getEquipmentStatusReadinessPG() != null);
1980: }
1981:
1982: /** Set the EquipmentStatusReadinessPG property.
1983: * The default implementation will create a new EquipmentStatusReadinessPG
1984: * property and add it to the otherPropertyGroup list.
1985: * Many subclasses override with local slots.
1986: **/
1987: public void setEquipmentStatusReadinessPG(
1988: PropertyGroup aEquipmentStatusReadinessPG) {
1989: if (aEquipmentStatusReadinessPG == null) {
1990: removeOtherPropertyGroup(EquipmentStatusReadinessPG.class);
1991: } else {
1992: addOtherPropertyGroup(aEquipmentStatusReadinessPG);
1993: }
1994: }
1995:
1996: /** Search additional properties for a CostPG instance.
1997: * @return instance of CostPG or null.
1998: **/
1999: public CostPG getCostPG() {
2000: CostPG _tmp = (CostPG) resolvePG(CostPG.class);
2001: return (_tmp == CostPG.nullPG) ? null : _tmp;
2002: }
2003:
2004: /** Test for existence of a CostPG
2005: **/
2006: public boolean hasCostPG() {
2007: return (getCostPG() != null);
2008: }
2009:
2010: /** Set the CostPG property.
2011: * The default implementation will create a new CostPG
2012: * property and add it to the otherPropertyGroup list.
2013: * Many subclasses override with local slots.
2014: **/
2015: public void setCostPG(PropertyGroup aCostPG) {
2016: if (aCostPG == null) {
2017: removeOtherPropertyGroup(CostPG.class);
2018: } else {
2019: addOtherPropertyGroup(aCostPG);
2020: }
2021: }
2022:
2023: /** Search additional properties for a WaterPG instance.
2024: * @return instance of WaterPG or null.
2025: **/
2026: public WaterPG getWaterPG() {
2027: WaterPG _tmp = (WaterPG) resolvePG(WaterPG.class);
2028: return (_tmp == WaterPG.nullPG) ? null : _tmp;
2029: }
2030:
2031: /** Test for existence of a WaterPG
2032: **/
2033: public boolean hasWaterPG() {
2034: return (getWaterPG() != null);
2035: }
2036:
2037: /** Set the WaterPG property.
2038: * The default implementation will create a new WaterPG
2039: * property and add it to the otherPropertyGroup list.
2040: * Many subclasses override with local slots.
2041: **/
2042: public void setWaterPG(PropertyGroup aWaterPG) {
2043: if (aWaterPG == null) {
2044: removeOtherPropertyGroup(WaterPG.class);
2045: } else {
2046: addOtherPropertyGroup(aWaterPG);
2047: }
2048: }
2049:
2050: /** Search additional properties for a MEIPG instance.
2051: * @return instance of MEIPG or null.
2052: **/
2053: public MEIPG getMEIPG() {
2054: MEIPG _tmp = (MEIPG) resolvePG(MEIPG.class);
2055: return (_tmp == MEIPG.nullPG) ? null : _tmp;
2056: }
2057:
2058: /** Test for existence of a MEIPG
2059: **/
2060: public boolean hasMEIPG() {
2061: return (getMEIPG() != null);
2062: }
2063:
2064: /** Set the MEIPG property.
2065: * The default implementation will create a new MEIPG
2066: * property and add it to the otherPropertyGroup list.
2067: * Many subclasses override with local slots.
2068: **/
2069: public void setMEIPG(PropertyGroup aMEIPG) {
2070: if (aMEIPG == null) {
2071: removeOtherPropertyGroup(MEIPG.class);
2072: } else {
2073: addOtherPropertyGroup(aMEIPG);
2074: }
2075: }
2076:
2077: /** Search additional properties for a EquipmentOHReadinessPG instance.
2078: * @return instance of EquipmentOHReadinessPG or null.
2079: **/
2080: public EquipmentOHReadinessPG getEquipmentOHReadinessPG() {
2081: EquipmentOHReadinessPG _tmp = (EquipmentOHReadinessPG) resolvePG(EquipmentOHReadinessPG.class);
2082: return (_tmp == EquipmentOHReadinessPG.nullPG) ? null : _tmp;
2083: }
2084:
2085: /** Test for existence of a EquipmentOHReadinessPG
2086: **/
2087: public boolean hasEquipmentOHReadinessPG() {
2088: return (getEquipmentOHReadinessPG() != null);
2089: }
2090:
2091: /** Set the EquipmentOHReadinessPG property.
2092: * The default implementation will create a new EquipmentOHReadinessPG
2093: * property and add it to the otherPropertyGroup list.
2094: * Many subclasses override with local slots.
2095: **/
2096: public void setEquipmentOHReadinessPG(
2097: PropertyGroup aEquipmentOHReadinessPG) {
2098: if (aEquipmentOHReadinessPG == null) {
2099: removeOtherPropertyGroup(EquipmentOHReadinessPG.class);
2100: } else {
2101: addOtherPropertyGroup(aEquipmentOHReadinessPG);
2102: }
2103: }
2104:
2105: /** Search additional properties for a AirSelfPropulsionPG instance.
2106: * @return instance of AirSelfPropulsionPG or null.
2107: **/
2108: public AirSelfPropulsionPG getAirSelfPropulsionPG() {
2109: AirSelfPropulsionPG _tmp = (AirSelfPropulsionPG) resolvePG(AirSelfPropulsionPG.class);
2110: return (_tmp == AirSelfPropulsionPG.nullPG) ? null : _tmp;
2111: }
2112:
2113: /** Test for existence of a AirSelfPropulsionPG
2114: **/
2115: public boolean hasAirSelfPropulsionPG() {
2116: return (getAirSelfPropulsionPG() != null);
2117: }
2118:
2119: /** Set the AirSelfPropulsionPG property.
2120: * The default implementation will create a new AirSelfPropulsionPG
2121: * property and add it to the otherPropertyGroup list.
2122: * Many subclasses override with local slots.
2123: **/
2124: public void setAirSelfPropulsionPG(
2125: PropertyGroup aAirSelfPropulsionPG) {
2126: if (aAirSelfPropulsionPG == null) {
2127: removeOtherPropertyGroup(AirSelfPropulsionPG.class);
2128: } else {
2129: addOtherPropertyGroup(aAirSelfPropulsionPG);
2130: }
2131: }
2132:
2133: /** Search additional properties for a FoodPG instance.
2134: * @return instance of FoodPG or null.
2135: **/
2136: public FoodPG getFoodPG() {
2137: FoodPG _tmp = (FoodPG) resolvePG(FoodPG.class);
2138: return (_tmp == FoodPG.nullPG) ? null : _tmp;
2139: }
2140:
2141: /** Test for existence of a FoodPG
2142: **/
2143: public boolean hasFoodPG() {
2144: return (getFoodPG() != null);
2145: }
2146:
2147: /** Set the FoodPG property.
2148: * The default implementation will create a new FoodPG
2149: * property and add it to the otherPropertyGroup list.
2150: * Many subclasses override with local slots.
2151: **/
2152: public void setFoodPG(PropertyGroup aFoodPG) {
2153: if (aFoodPG == null) {
2154: removeOtherPropertyGroup(FoodPG.class);
2155: } else {
2156: addOtherPropertyGroup(aFoodPG);
2157: }
2158: }
2159:
2160: /** Search additional properties for a SeaConditionPG instance.
2161: * @return instance of SeaConditionPG or null.
2162: **/
2163: public SeaConditionPG getSeaConditionPG() {
2164: SeaConditionPG _tmp = (SeaConditionPG) resolvePG(SeaConditionPG.class);
2165: return (_tmp == SeaConditionPG.nullPG) ? null : _tmp;
2166: }
2167:
2168: /** Test for existence of a SeaConditionPG
2169: **/
2170: public boolean hasSeaConditionPG() {
2171: return (getSeaConditionPG() != null);
2172: }
2173:
2174: /** Set the SeaConditionPG property.
2175: * The default implementation will create a new SeaConditionPG
2176: * property and add it to the otherPropertyGroup list.
2177: * Many subclasses override with local slots.
2178: **/
2179: public void setSeaConditionPG(PropertyGroup aSeaConditionPG) {
2180: if (aSeaConditionPG == null) {
2181: removeOtherPropertyGroup(SeaConditionPG.class);
2182: } else {
2183: addOtherPropertyGroup(aSeaConditionPG);
2184: }
2185: }
2186:
2187: /** Search additional properties for a AssignedPG instance.
2188: * @return instance of AssignedPG or null.
2189: **/
2190: public AssignedPG getAssignedPG() {
2191: AssignedPG _tmp = (AssignedPG) resolvePG(AssignedPG.class);
2192: return (_tmp == AssignedPG.nullPG) ? null : _tmp;
2193: }
2194:
2195: /** Test for existence of a AssignedPG
2196: **/
2197: public boolean hasAssignedPG() {
2198: return (getAssignedPG() != null);
2199: }
2200:
2201: /** Set the AssignedPG property.
2202: * The default implementation will create a new AssignedPG
2203: * property and add it to the otherPropertyGroup list.
2204: * Many subclasses override with local slots.
2205: **/
2206: public void setAssignedPG(PropertyGroup aAssignedPG) {
2207: if (aAssignedPG == null) {
2208: removeOtherPropertyGroup(AssignedPG.class);
2209: } else {
2210: addOtherPropertyGroup(aAssignedPG);
2211: }
2212: }
2213:
2214: /** Search additional properties for a MilitaryOrgPG instance.
2215: * @return instance of MilitaryOrgPG or null.
2216: **/
2217: public MilitaryOrgPG getMilitaryOrgPG() {
2218: MilitaryOrgPG _tmp = (MilitaryOrgPG) resolvePG(MilitaryOrgPG.class);
2219: return (_tmp == MilitaryOrgPG.nullPG) ? null : _tmp;
2220: }
2221:
2222: /** Test for existence of a MilitaryOrgPG
2223: **/
2224: public boolean hasMilitaryOrgPG() {
2225: return (getMilitaryOrgPG() != null);
2226: }
2227:
2228: /** Set the MilitaryOrgPG property.
2229: * The default implementation will create a new MilitaryOrgPG
2230: * property and add it to the otherPropertyGroup list.
2231: * Many subclasses override with local slots.
2232: **/
2233: public void setMilitaryOrgPG(PropertyGroup aMilitaryOrgPG) {
2234: if (aMilitaryOrgPG == null) {
2235: removeOtherPropertyGroup(MilitaryOrgPG.class);
2236: } else {
2237: addOtherPropertyGroup(aMilitaryOrgPG);
2238: }
2239: }
2240:
2241: /** Search additional properties for a ShipConfigurationPG instance.
2242: * @return instance of ShipConfigurationPG or null.
2243: **/
2244: public ShipConfigurationPG getShipConfigurationPG() {
2245: ShipConfigurationPG _tmp = (ShipConfigurationPG) resolvePG(ShipConfigurationPG.class);
2246: return (_tmp == ShipConfigurationPG.nullPG) ? null : _tmp;
2247: }
2248:
2249: /** Test for existence of a ShipConfigurationPG
2250: **/
2251: public boolean hasShipConfigurationPG() {
2252: return (getShipConfigurationPG() != null);
2253: }
2254:
2255: /** Set the ShipConfigurationPG property.
2256: * The default implementation will create a new ShipConfigurationPG
2257: * property and add it to the otherPropertyGroup list.
2258: * Many subclasses override with local slots.
2259: **/
2260: public void setShipConfigurationPG(
2261: PropertyGroup aShipConfigurationPG) {
2262: if (aShipConfigurationPG == null) {
2263: removeOtherPropertyGroup(ShipConfigurationPG.class);
2264: } else {
2265: addOtherPropertyGroup(aShipConfigurationPG);
2266: }
2267: }
2268:
2269: /** Search additional properties for a RepairabilityPG instance.
2270: * @return instance of RepairabilityPG or null.
2271: **/
2272: public RepairabilityPG getRepairabilityPG() {
2273: RepairabilityPG _tmp = (RepairabilityPG) resolvePG(RepairabilityPG.class);
2274: return (_tmp == RepairabilityPG.nullPG) ? null : _tmp;
2275: }
2276:
2277: /** Test for existence of a RepairabilityPG
2278: **/
2279: public boolean hasRepairabilityPG() {
2280: return (getRepairabilityPG() != null);
2281: }
2282:
2283: /** Set the RepairabilityPG property.
2284: * The default implementation will create a new RepairabilityPG
2285: * property and add it to the otherPropertyGroup list.
2286: * Many subclasses override with local slots.
2287: **/
2288: public void setRepairabilityPG(PropertyGroup aRepairabilityPG) {
2289: if (aRepairabilityPG == null) {
2290: removeOtherPropertyGroup(RepairabilityPG.class);
2291: } else {
2292: addOtherPropertyGroup(aRepairabilityPG);
2293: }
2294: }
2295:
2296: /** Search additional properties for a WaterSupplyPG instance.
2297: * @return instance of WaterSupplyPG or null.
2298: **/
2299: public WaterSupplyPG getWaterSupplyPG() {
2300: WaterSupplyPG _tmp = (WaterSupplyPG) resolvePG(WaterSupplyPG.class);
2301: return (_tmp == WaterSupplyPG.nullPG) ? null : _tmp;
2302: }
2303:
2304: /** Test for existence of a WaterSupplyPG
2305: **/
2306: public boolean hasWaterSupplyPG() {
2307: return (getWaterSupplyPG() != null);
2308: }
2309:
2310: /** Set the WaterSupplyPG property.
2311: * The default implementation will create a new WaterSupplyPG
2312: * property and add it to the otherPropertyGroup list.
2313: * Many subclasses override with local slots.
2314: **/
2315: public void setWaterSupplyPG(PropertyGroup aWaterSupplyPG) {
2316: if (aWaterSupplyPG == null) {
2317: removeOtherPropertyGroup(WaterSupplyPG.class);
2318: } else {
2319: addOtherPropertyGroup(aWaterSupplyPG);
2320: }
2321: }
2322:
2323: /** Search additional properties for a LiquidSupplyPG instance.
2324: * @return instance of LiquidSupplyPG or null.
2325: **/
2326: public LiquidSupplyPG getLiquidSupplyPG() {
2327: LiquidSupplyPG _tmp = (LiquidSupplyPG) resolvePG(LiquidSupplyPG.class);
2328: return (_tmp == LiquidSupplyPG.nullPG) ? null : _tmp;
2329: }
2330:
2331: /** Test for existence of a LiquidSupplyPG
2332: **/
2333: public boolean hasLiquidSupplyPG() {
2334: return (getLiquidSupplyPG() != null);
2335: }
2336:
2337: /** Set the LiquidSupplyPG property.
2338: * The default implementation will create a new LiquidSupplyPG
2339: * property and add it to the otherPropertyGroup list.
2340: * Many subclasses override with local slots.
2341: **/
2342: public void setLiquidSupplyPG(PropertyGroup aLiquidSupplyPG) {
2343: if (aLiquidSupplyPG == null) {
2344: removeOtherPropertyGroup(LiquidSupplyPG.class);
2345: } else {
2346: addOtherPropertyGroup(aLiquidSupplyPG);
2347: }
2348: }
2349:
2350: /** Search additional properties for a TransportationPG instance.
2351: * @return instance of TransportationPG or null.
2352: **/
2353: public TransportationPG getTransportationPG() {
2354: TransportationPG _tmp = (TransportationPG) resolvePG(TransportationPG.class);
2355: return (_tmp == TransportationPG.nullPG) ? null : _tmp;
2356: }
2357:
2358: /** Test for existence of a TransportationPG
2359: **/
2360: public boolean hasTransportationPG() {
2361: return (getTransportationPG() != null);
2362: }
2363:
2364: /** Set the TransportationPG property.
2365: * The default implementation will create a new TransportationPG
2366: * property and add it to the otherPropertyGroup list.
2367: * Many subclasses override with local slots.
2368: **/
2369: public void setTransportationPG(PropertyGroup aTransportationPG) {
2370: if (aTransportationPG == null) {
2371: removeOtherPropertyGroup(TransportationPG.class);
2372: } else {
2373: addOtherPropertyGroup(aTransportationPG);
2374: }
2375: }
2376:
2377: /** Search additional properties for a PackagePG instance.
2378: * @return instance of PackagePG or null.
2379: **/
2380: public PackagePG getPackagePG() {
2381: PackagePG _tmp = (PackagePG) resolvePG(PackagePG.class);
2382: return (_tmp == PackagePG.nullPG) ? null : _tmp;
2383: }
2384:
2385: /** Test for existence of a PackagePG
2386: **/
2387: public boolean hasPackagePG() {
2388: return (getPackagePG() != null);
2389: }
2390:
2391: /** Set the PackagePG property.
2392: * The default implementation will create a new PackagePG
2393: * property and add it to the otherPropertyGroup list.
2394: * Many subclasses override with local slots.
2395: **/
2396: public void setPackagePG(PropertyGroup aPackagePG) {
2397: if (aPackagePG == null) {
2398: removeOtherPropertyGroup(PackagePG.class);
2399: } else {
2400: addOtherPropertyGroup(aPackagePG);
2401: }
2402: }
2403:
2404: /** Search additional properties for a AirLinkPG instance.
2405: * @return instance of AirLinkPG or null.
2406: **/
2407: public AirLinkPG getAirLinkPG() {
2408: AirLinkPG _tmp = (AirLinkPG) resolvePG(AirLinkPG.class);
2409: return (_tmp == AirLinkPG.nullPG) ? null : _tmp;
2410: }
2411:
2412: /** Test for existence of a AirLinkPG
2413: **/
2414: public boolean hasAirLinkPG() {
2415: return (getAirLinkPG() != null);
2416: }
2417:
2418: /** Set the AirLinkPG property.
2419: * The default implementation will create a new AirLinkPG
2420: * property and add it to the otherPropertyGroup list.
2421: * Many subclasses override with local slots.
2422: **/
2423: public void setAirLinkPG(PropertyGroup aAirLinkPG) {
2424: if (aAirLinkPG == null) {
2425: removeOtherPropertyGroup(AirLinkPG.class);
2426: } else {
2427: addOtherPropertyGroup(aAirLinkPG);
2428: }
2429: }
2430:
2431: /** Search additional properties for a OrganizationPG instance.
2432: * @return instance of OrganizationPG or null.
2433: **/
2434: public OrganizationPG getOrganizationPG() {
2435: OrganizationPG _tmp = (OrganizationPG) resolvePG(OrganizationPG.class);
2436: return (_tmp == OrganizationPG.nullPG) ? null : _tmp;
2437: }
2438:
2439: /** Test for existence of a OrganizationPG
2440: **/
2441: public boolean hasOrganizationPG() {
2442: return (getOrganizationPG() != null);
2443: }
2444:
2445: /** Set the OrganizationPG property.
2446: * The default implementation will create a new OrganizationPG
2447: * property and add it to the otherPropertyGroup list.
2448: * Many subclasses override with local slots.
2449: **/
2450: public void setOrganizationPG(PropertyGroup aOrganizationPG) {
2451: if (aOrganizationPG == null) {
2452: removeOtherPropertyGroup(OrganizationPG.class);
2453: } else {
2454: addOtherPropertyGroup(aOrganizationPG);
2455: }
2456: }
2457:
2458: }
|