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:26:05 EDT 2007 from /u01/builds/cougaar/B12_4/B12_4/070927151721/src/albbn/src/org/cougaar/logistics/plugin/inventory/logisticsprops.def - DO NOT HAND EDIT */
0028: /** Primary client interface for LogisticsInventoryPG.
0029: * @see NewLogisticsInventoryPG
0030: * @see LogisticsInventoryPGImpl
0031: **/package org.cougaar.logistics.plugin.inventory;
0032:
0033: import org.cougaar.planning.ldm.measure.*;
0034: import org.cougaar.planning.ldm.asset.*;
0035: import org.cougaar.planning.ldm.plan.*;
0036: import java.util.*;
0037:
0038: import org.cougaar.logistics.plugin.inventory.InventoryPlugin;
0039: import org.cougaar.logistics.plugin.inventory.InventoryManager;
0040: import org.cougaar.glm.ldm.asset.Inventory;
0041: import org.cougaar.glm.ldm.asset.Organization;
0042:
0043: public interface LogisticsInventoryPG extends PropertyGroup,
0044: org.cougaar.planning.ldm.dq.HasDataQuality {
0045: Asset getMei();
0046:
0047: Asset getResource();
0048:
0049: double getCapacity();
0050:
0051: boolean getFillToCapacity();
0052:
0053: long getSupplierArrivalTime();
0054:
0055: double getInitialLevel();
0056:
0057: boolean getIsLevel2();
0058:
0059: Organization getOrg();
0060:
0061: void initialize(long today, long oplanEndTime, int critLevel,
0062: int reorderPeriod, int ost, long bucketSize, long now,
0063: boolean logToCSV, InventoryManager parentPlugin);
0064:
0065: void addWithdrawProjection(Task task);
0066:
0067: double getProjectionTaskDemand(Task task, int bucket, long start,
0068: long end);
0069:
0070: void addWithdrawRequisition(Task task);
0071:
0072: void removeWithdrawProjection(Task task);
0073:
0074: void removeWithdrawRequisition(Task task);
0075:
0076: void addRefillRequisition(Task task);
0077:
0078: int getLastWithdrawBucket();
0079:
0080: int getFirstProjectWithdrawBucket();
0081:
0082: int getLastRefillRequisition();
0083:
0084: int getLastDemandBucket();
0085:
0086: void addRefillProjection(Task task);
0087:
0088: void setEndOfLevelSixBucket(int bucket);
0089:
0090: int getEndOfLevelSixBucket();
0091:
0092: void removeRefillProjection(Task task);
0093:
0094: void removeRefillRequisition(Task task);
0095:
0096: List clearRefillTasks(Date now);
0097:
0098: List clearRefillProjectionTasks(long now);
0099:
0100: List getOverlappingRefillProjections();
0101:
0102: ArrayList getRefillRequisitions();
0103:
0104: ArrayList getRefillProjection(int bucket);
0105:
0106: double getCriticalLevel(int bucket);
0107:
0108: double getLevel(int bucket);
0109:
0110: void setLevel(int bucket, double value);
0111:
0112: void setTarget(int bucket, double value);
0113:
0114: void updateRefillRequisition(Task task);
0115:
0116: void updateWithdrawRequisition(Task task);
0117:
0118: void updateRefillProjection(Task task);
0119:
0120: void updateWithdrawProjection(Task task);
0121:
0122: double getProjectedDemand(int bucket);
0123:
0124: Collection getProjectedDemandTasks(int bucket);
0125:
0126: double getActualDemand(int bucket);
0127:
0128: Collection getActualDemandTasks(int bucket);
0129:
0130: double getReorderPeriod();
0131:
0132: Collection getWithdrawTasks(int bucket);
0133:
0134: Collection getProjectWithdrawTasks(int bucket);
0135:
0136: void rebuildCustomerHash();
0137:
0138: long convertBucketToTime(int bucket);
0139:
0140: int convertTimeToBucket(long time, boolean partialBuckets);
0141:
0142: long getBucketMillis();
0143:
0144: long getStartTime();
0145:
0146: int getStartBucket();
0147:
0148: HashMap getCustomerHash();
0149:
0150: void logAllToCSVFile(long aCycleStamp);
0151:
0152: int getCriticalLevel();
0153:
0154: boolean getFailuresFlag();
0155:
0156: void setFailuresFlag(boolean value);
0157:
0158: void setArrivalTime(long arrivalTime);
0159:
0160: long getArrivalTime();
0161:
0162: void setStartCDay(long startCTime);
0163:
0164: void Test();
0165:
0166: void takeSnapshot(Inventory inventory);
0167:
0168: ArrayList getProjWithdrawList();
0169:
0170: ArrayList getWithdrawList();
0171:
0172: ArrayList getProjSupplyList();
0173:
0174: ArrayList getSupplyList();
0175:
0176: Schedule getBufferedCritLevels();
0177:
0178: Schedule getBufferedInvLevels();
0179:
0180: Schedule getBufferedTargetLevels();
0181:
0182: ArrayList getActualDemandTasksList();
0183:
0184: long getEffectiveProjectionStart(Task task, long start);
0185:
0186: void reinitialize(boolean logToCSV, InventoryManager parentPlugin);
0187:
0188: void clearTargetLevels(int startBucket);
0189:
0190: void recalculateInitialLevel();
0191:
0192: ShortfallInventory checkForShortfall(String invID,
0193: String unitOfIssue);
0194:
0195: String getItemName();
0196:
0197: // introspection and construction
0198: /** the method of factoryClass that creates this type **/
0199: String factoryMethod = "newLogisticsInventoryPG";
0200: /** the (mutable) class type returned by factoryMethod **/
0201: String mutableClass = "org.cougaar.logistics.plugin.inventory.NewLogisticsInventoryPG";
0202: /** the factory class **/
0203: Class factoryClass = org.cougaar.logistics.plugin.inventory.PropertyGroupFactory.class;
0204: /** the (immutable) class type returned by domain factory **/
0205: Class primaryClass = org.cougaar.logistics.plugin.inventory.LogisticsInventoryPG.class;
0206: String assetSetter = "setLogisticsInventoryPG";
0207: String assetGetter = "getLogisticsInventoryPG";
0208: /** The Null instance for indicating that the PG definitely has no value **/
0209: LogisticsInventoryPG nullPG = new Null_LogisticsInventoryPG();
0210:
0211: /** Null_PG implementation for LogisticsInventoryPG **/
0212: final class Null_LogisticsInventoryPG implements
0213: LogisticsInventoryPG, Null_PG {
0214: public Asset getMei() {
0215: throw new UndefinedValueException();
0216: }
0217:
0218: public Asset getResource() {
0219: throw new UndefinedValueException();
0220: }
0221:
0222: public double getCapacity() {
0223: throw new UndefinedValueException();
0224: }
0225:
0226: public boolean getFillToCapacity() {
0227: throw new UndefinedValueException();
0228: }
0229:
0230: public long getSupplierArrivalTime() {
0231: throw new UndefinedValueException();
0232: }
0233:
0234: public double getInitialLevel() {
0235: throw new UndefinedValueException();
0236: }
0237:
0238: public boolean getIsLevel2() {
0239: throw new UndefinedValueException();
0240: }
0241:
0242: public Organization getOrg() {
0243: throw new UndefinedValueException();
0244: }
0245:
0246: public LogisticsInventoryBG getLogInvBG() {
0247: throw new UndefinedValueException();
0248: }
0249:
0250: public void setLogInvBG(LogisticsInventoryBG _logInvBG) {
0251: throw new UndefinedValueException();
0252: }
0253:
0254: public void initialize(long today, long oplanEndTime,
0255: int critLevel, int reorderPeriod, int ost,
0256: long bucketSize, long now, boolean logToCSV,
0257: InventoryManager parentPlugin) {
0258: throw new UndefinedValueException();
0259: }
0260:
0261: public void addWithdrawProjection(Task task) {
0262: throw new UndefinedValueException();
0263: }
0264:
0265: public double getProjectionTaskDemand(Task task, int bucket,
0266: long start, long end) {
0267: throw new UndefinedValueException();
0268: }
0269:
0270: public void addWithdrawRequisition(Task task) {
0271: throw new UndefinedValueException();
0272: }
0273:
0274: public void removeWithdrawProjection(Task task) {
0275: throw new UndefinedValueException();
0276: }
0277:
0278: public void removeWithdrawRequisition(Task task) {
0279: throw new UndefinedValueException();
0280: }
0281:
0282: public void addRefillRequisition(Task task) {
0283: throw new UndefinedValueException();
0284: }
0285:
0286: public int getLastWithdrawBucket() {
0287: throw new UndefinedValueException();
0288: }
0289:
0290: public int getFirstProjectWithdrawBucket() {
0291: throw new UndefinedValueException();
0292: }
0293:
0294: public int getLastRefillRequisition() {
0295: throw new UndefinedValueException();
0296: }
0297:
0298: public int getLastDemandBucket() {
0299: throw new UndefinedValueException();
0300: }
0301:
0302: public void addRefillProjection(Task task) {
0303: throw new UndefinedValueException();
0304: }
0305:
0306: public void setEndOfLevelSixBucket(int bucket) {
0307: throw new UndefinedValueException();
0308: }
0309:
0310: public int getEndOfLevelSixBucket() {
0311: throw new UndefinedValueException();
0312: }
0313:
0314: public void removeRefillProjection(Task task) {
0315: throw new UndefinedValueException();
0316: }
0317:
0318: public void removeRefillRequisition(Task task) {
0319: throw new UndefinedValueException();
0320: }
0321:
0322: public List clearRefillTasks(Date now) {
0323: throw new UndefinedValueException();
0324: }
0325:
0326: public List clearRefillProjectionTasks(long now) {
0327: throw new UndefinedValueException();
0328: }
0329:
0330: public List getOverlappingRefillProjections() {
0331: throw new UndefinedValueException();
0332: }
0333:
0334: public ArrayList getRefillRequisitions() {
0335: throw new UndefinedValueException();
0336: }
0337:
0338: public ArrayList getRefillProjection(int bucket) {
0339: throw new UndefinedValueException();
0340: }
0341:
0342: public double getCriticalLevel(int bucket) {
0343: throw new UndefinedValueException();
0344: }
0345:
0346: public double getLevel(int bucket) {
0347: throw new UndefinedValueException();
0348: }
0349:
0350: public void setLevel(int bucket, double value) {
0351: throw new UndefinedValueException();
0352: }
0353:
0354: public void setTarget(int bucket, double value) {
0355: throw new UndefinedValueException();
0356: }
0357:
0358: public void updateRefillRequisition(Task task) {
0359: throw new UndefinedValueException();
0360: }
0361:
0362: public void updateWithdrawRequisition(Task task) {
0363: throw new UndefinedValueException();
0364: }
0365:
0366: public void updateRefillProjection(Task task) {
0367: throw new UndefinedValueException();
0368: }
0369:
0370: public void updateWithdrawProjection(Task task) {
0371: throw new UndefinedValueException();
0372: }
0373:
0374: public double getProjectedDemand(int bucket) {
0375: throw new UndefinedValueException();
0376: }
0377:
0378: public Collection getProjectedDemandTasks(int bucket) {
0379: throw new UndefinedValueException();
0380: }
0381:
0382: public double getActualDemand(int bucket) {
0383: throw new UndefinedValueException();
0384: }
0385:
0386: public Collection getActualDemandTasks(int bucket) {
0387: throw new UndefinedValueException();
0388: }
0389:
0390: public double getReorderPeriod() {
0391: throw new UndefinedValueException();
0392: }
0393:
0394: public Collection getWithdrawTasks(int bucket) {
0395: throw new UndefinedValueException();
0396: }
0397:
0398: public Collection getProjectWithdrawTasks(int bucket) {
0399: throw new UndefinedValueException();
0400: }
0401:
0402: public void rebuildCustomerHash() {
0403: throw new UndefinedValueException();
0404: }
0405:
0406: public long convertBucketToTime(int bucket) {
0407: throw new UndefinedValueException();
0408: }
0409:
0410: public int convertTimeToBucket(long time, boolean partialBuckets) {
0411: throw new UndefinedValueException();
0412: }
0413:
0414: public long getBucketMillis() {
0415: throw new UndefinedValueException();
0416: }
0417:
0418: public long getStartTime() {
0419: throw new UndefinedValueException();
0420: }
0421:
0422: public int getStartBucket() {
0423: throw new UndefinedValueException();
0424: }
0425:
0426: public HashMap getCustomerHash() {
0427: throw new UndefinedValueException();
0428: }
0429:
0430: public void logAllToCSVFile(long aCycleStamp) {
0431: throw new UndefinedValueException();
0432: }
0433:
0434: public int getCriticalLevel() {
0435: throw new UndefinedValueException();
0436: }
0437:
0438: public boolean getFailuresFlag() {
0439: throw new UndefinedValueException();
0440: }
0441:
0442: public void setFailuresFlag(boolean value) {
0443: throw new UndefinedValueException();
0444: }
0445:
0446: public void setArrivalTime(long arrivalTime) {
0447: throw new UndefinedValueException();
0448: }
0449:
0450: public long getArrivalTime() {
0451: throw new UndefinedValueException();
0452: }
0453:
0454: public void setStartCDay(long startCTime) {
0455: throw new UndefinedValueException();
0456: }
0457:
0458: public void Test() {
0459: throw new UndefinedValueException();
0460: }
0461:
0462: public void takeSnapshot(Inventory inventory) {
0463: throw new UndefinedValueException();
0464: }
0465:
0466: public ArrayList getProjWithdrawList() {
0467: throw new UndefinedValueException();
0468: }
0469:
0470: public ArrayList getWithdrawList() {
0471: throw new UndefinedValueException();
0472: }
0473:
0474: public ArrayList getProjSupplyList() {
0475: throw new UndefinedValueException();
0476: }
0477:
0478: public ArrayList getSupplyList() {
0479: throw new UndefinedValueException();
0480: }
0481:
0482: public Schedule getBufferedCritLevels() {
0483: throw new UndefinedValueException();
0484: }
0485:
0486: public Schedule getBufferedInvLevels() {
0487: throw new UndefinedValueException();
0488: }
0489:
0490: public Schedule getBufferedTargetLevels() {
0491: throw new UndefinedValueException();
0492: }
0493:
0494: public ArrayList getActualDemandTasksList() {
0495: throw new UndefinedValueException();
0496: }
0497:
0498: public long getEffectiveProjectionStart(Task task, long start) {
0499: throw new UndefinedValueException();
0500: }
0501:
0502: public void reinitialize(boolean logToCSV,
0503: InventoryManager parentPlugin) {
0504: throw new UndefinedValueException();
0505: }
0506:
0507: public void clearTargetLevels(int startBucket) {
0508: throw new UndefinedValueException();
0509: }
0510:
0511: public void recalculateInitialLevel() {
0512: throw new UndefinedValueException();
0513: }
0514:
0515: public ShortfallInventory checkForShortfall(String invID,
0516: String unitOfIssue) {
0517: throw new UndefinedValueException();
0518: }
0519:
0520: public String getItemName() {
0521: throw new UndefinedValueException();
0522: }
0523:
0524: public boolean equals(Object object) {
0525: throw new UndefinedValueException();
0526: }
0527:
0528: public Object clone() throws CloneNotSupportedException {
0529: throw new CloneNotSupportedException();
0530: }
0531:
0532: public NewPropertyGroup unlock(Object key) {
0533: return null;
0534: }
0535:
0536: public PropertyGroup lock(Object key) {
0537: return null;
0538: }
0539:
0540: public PropertyGroup lock() {
0541: return null;
0542: }
0543:
0544: public PropertyGroup copy() {
0545: return null;
0546: }
0547:
0548: public Class getPrimaryClass() {
0549: return primaryClass;
0550: }
0551:
0552: public String getAssetGetMethod() {
0553: return assetGetter;
0554: }
0555:
0556: public String getAssetSetMethod() {
0557: return assetSetter;
0558: }
0559:
0560: public Class getIntrospectionClass() {
0561: return LogisticsInventoryPGImpl.class;
0562: }
0563:
0564: public boolean hasDataQuality() {
0565: return false;
0566: }
0567:
0568: public org.cougaar.planning.ldm.dq.DataQuality getDataQuality() {
0569: return null;
0570: }
0571: }
0572:
0573: /** Future PG implementation for LogisticsInventoryPG **/
0574: final class Future implements LogisticsInventoryPG, Future_PG {
0575: public Asset getMei() {
0576: waitForFinalize();
0577: return _real.getMei();
0578: }
0579:
0580: public Asset getResource() {
0581: waitForFinalize();
0582: return _real.getResource();
0583: }
0584:
0585: public double getCapacity() {
0586: waitForFinalize();
0587: return _real.getCapacity();
0588: }
0589:
0590: public boolean getFillToCapacity() {
0591: waitForFinalize();
0592: return _real.getFillToCapacity();
0593: }
0594:
0595: public long getSupplierArrivalTime() {
0596: waitForFinalize();
0597: return _real.getSupplierArrivalTime();
0598: }
0599:
0600: public double getInitialLevel() {
0601: waitForFinalize();
0602: return _real.getInitialLevel();
0603: }
0604:
0605: public boolean getIsLevel2() {
0606: waitForFinalize();
0607: return _real.getIsLevel2();
0608: }
0609:
0610: public Organization getOrg() {
0611: waitForFinalize();
0612: return _real.getOrg();
0613: }
0614:
0615: public boolean equals(Object object) {
0616: waitForFinalize();
0617: return _real.equals(object);
0618: }
0619:
0620: public void initialize(long today, long oplanEndTime,
0621: int critLevel, int reorderPeriod, int ost,
0622: long bucketSize, long now, boolean logToCSV,
0623: InventoryManager parentPlugin) {
0624: waitForFinalize();
0625: _real.initialize(today, oplanEndTime, critLevel,
0626: reorderPeriod, ost, bucketSize, now, logToCSV,
0627: parentPlugin);
0628: }
0629:
0630: public void addWithdrawProjection(Task task) {
0631: waitForFinalize();
0632: _real.addWithdrawProjection(task);
0633: }
0634:
0635: public double getProjectionTaskDemand(Task task, int bucket,
0636: long start, long end) {
0637: waitForFinalize();
0638: return _real.getProjectionTaskDemand(task, bucket, start,
0639: end);
0640: }
0641:
0642: public void addWithdrawRequisition(Task task) {
0643: waitForFinalize();
0644: _real.addWithdrawRequisition(task);
0645: }
0646:
0647: public void removeWithdrawProjection(Task task) {
0648: waitForFinalize();
0649: _real.removeWithdrawProjection(task);
0650: }
0651:
0652: public void removeWithdrawRequisition(Task task) {
0653: waitForFinalize();
0654: _real.removeWithdrawRequisition(task);
0655: }
0656:
0657: public void addRefillRequisition(Task task) {
0658: waitForFinalize();
0659: _real.addRefillRequisition(task);
0660: }
0661:
0662: public int getLastWithdrawBucket() {
0663: waitForFinalize();
0664: return _real.getLastWithdrawBucket();
0665: }
0666:
0667: public int getFirstProjectWithdrawBucket() {
0668: waitForFinalize();
0669: return _real.getFirstProjectWithdrawBucket();
0670: }
0671:
0672: public int getLastRefillRequisition() {
0673: waitForFinalize();
0674: return _real.getLastRefillRequisition();
0675: }
0676:
0677: public int getLastDemandBucket() {
0678: waitForFinalize();
0679: return _real.getLastDemandBucket();
0680: }
0681:
0682: public void addRefillProjection(Task task) {
0683: waitForFinalize();
0684: _real.addRefillProjection(task);
0685: }
0686:
0687: public void setEndOfLevelSixBucket(int bucket) {
0688: waitForFinalize();
0689: _real.setEndOfLevelSixBucket(bucket);
0690: }
0691:
0692: public int getEndOfLevelSixBucket() {
0693: waitForFinalize();
0694: return _real.getEndOfLevelSixBucket();
0695: }
0696:
0697: public void removeRefillProjection(Task task) {
0698: waitForFinalize();
0699: _real.removeRefillProjection(task);
0700: }
0701:
0702: public void removeRefillRequisition(Task task) {
0703: waitForFinalize();
0704: _real.removeRefillRequisition(task);
0705: }
0706:
0707: public List clearRefillTasks(Date now) {
0708: waitForFinalize();
0709: return _real.clearRefillTasks(now);
0710: }
0711:
0712: public List clearRefillProjectionTasks(long now) {
0713: waitForFinalize();
0714: return _real.clearRefillProjectionTasks(now);
0715: }
0716:
0717: public List getOverlappingRefillProjections() {
0718: waitForFinalize();
0719: return _real.getOverlappingRefillProjections();
0720: }
0721:
0722: public ArrayList getRefillRequisitions() {
0723: waitForFinalize();
0724: return _real.getRefillRequisitions();
0725: }
0726:
0727: public ArrayList getRefillProjection(int bucket) {
0728: waitForFinalize();
0729: return _real.getRefillProjection(bucket);
0730: }
0731:
0732: public double getCriticalLevel(int bucket) {
0733: waitForFinalize();
0734: return _real.getCriticalLevel(bucket);
0735: }
0736:
0737: public double getLevel(int bucket) {
0738: waitForFinalize();
0739: return _real.getLevel(bucket);
0740: }
0741:
0742: public void setLevel(int bucket, double value) {
0743: waitForFinalize();
0744: _real.setLevel(bucket, value);
0745: }
0746:
0747: public void setTarget(int bucket, double value) {
0748: waitForFinalize();
0749: _real.setTarget(bucket, value);
0750: }
0751:
0752: public void updateRefillRequisition(Task task) {
0753: waitForFinalize();
0754: _real.updateRefillRequisition(task);
0755: }
0756:
0757: public void updateWithdrawRequisition(Task task) {
0758: waitForFinalize();
0759: _real.updateWithdrawRequisition(task);
0760: }
0761:
0762: public void updateRefillProjection(Task task) {
0763: waitForFinalize();
0764: _real.updateRefillProjection(task);
0765: }
0766:
0767: public void updateWithdrawProjection(Task task) {
0768: waitForFinalize();
0769: _real.updateWithdrawProjection(task);
0770: }
0771:
0772: public double getProjectedDemand(int bucket) {
0773: waitForFinalize();
0774: return _real.getProjectedDemand(bucket);
0775: }
0776:
0777: public Collection getProjectedDemandTasks(int bucket) {
0778: waitForFinalize();
0779: return _real.getProjectedDemandTasks(bucket);
0780: }
0781:
0782: public double getActualDemand(int bucket) {
0783: waitForFinalize();
0784: return _real.getActualDemand(bucket);
0785: }
0786:
0787: public Collection getActualDemandTasks(int bucket) {
0788: waitForFinalize();
0789: return _real.getActualDemandTasks(bucket);
0790: }
0791:
0792: public double getReorderPeriod() {
0793: waitForFinalize();
0794: return _real.getReorderPeriod();
0795: }
0796:
0797: public Collection getWithdrawTasks(int bucket) {
0798: waitForFinalize();
0799: return _real.getWithdrawTasks(bucket);
0800: }
0801:
0802: public Collection getProjectWithdrawTasks(int bucket) {
0803: waitForFinalize();
0804: return _real.getProjectWithdrawTasks(bucket);
0805: }
0806:
0807: public void rebuildCustomerHash() {
0808: waitForFinalize();
0809: _real.rebuildCustomerHash();
0810: }
0811:
0812: public long convertBucketToTime(int bucket) {
0813: waitForFinalize();
0814: return _real.convertBucketToTime(bucket);
0815: }
0816:
0817: public int convertTimeToBucket(long time, boolean partialBuckets) {
0818: waitForFinalize();
0819: return _real.convertTimeToBucket(time, partialBuckets);
0820: }
0821:
0822: public long getBucketMillis() {
0823: waitForFinalize();
0824: return _real.getBucketMillis();
0825: }
0826:
0827: public long getStartTime() {
0828: waitForFinalize();
0829: return _real.getStartTime();
0830: }
0831:
0832: public int getStartBucket() {
0833: waitForFinalize();
0834: return _real.getStartBucket();
0835: }
0836:
0837: public HashMap getCustomerHash() {
0838: waitForFinalize();
0839: return _real.getCustomerHash();
0840: }
0841:
0842: public void logAllToCSVFile(long aCycleStamp) {
0843: waitForFinalize();
0844: _real.logAllToCSVFile(aCycleStamp);
0845: }
0846:
0847: public int getCriticalLevel() {
0848: waitForFinalize();
0849: return _real.getCriticalLevel();
0850: }
0851:
0852: public boolean getFailuresFlag() {
0853: waitForFinalize();
0854: return _real.getFailuresFlag();
0855: }
0856:
0857: public void setFailuresFlag(boolean value) {
0858: waitForFinalize();
0859: _real.setFailuresFlag(value);
0860: }
0861:
0862: public void setArrivalTime(long arrivalTime) {
0863: waitForFinalize();
0864: _real.setArrivalTime(arrivalTime);
0865: }
0866:
0867: public long getArrivalTime() {
0868: waitForFinalize();
0869: return _real.getArrivalTime();
0870: }
0871:
0872: public void setStartCDay(long startCTime) {
0873: waitForFinalize();
0874: _real.setStartCDay(startCTime);
0875: }
0876:
0877: public void Test() {
0878: waitForFinalize();
0879: _real.Test();
0880: }
0881:
0882: public void takeSnapshot(Inventory inventory) {
0883: waitForFinalize();
0884: _real.takeSnapshot(inventory);
0885: }
0886:
0887: public ArrayList getProjWithdrawList() {
0888: waitForFinalize();
0889: return _real.getProjWithdrawList();
0890: }
0891:
0892: public ArrayList getWithdrawList() {
0893: waitForFinalize();
0894: return _real.getWithdrawList();
0895: }
0896:
0897: public ArrayList getProjSupplyList() {
0898: waitForFinalize();
0899: return _real.getProjSupplyList();
0900: }
0901:
0902: public ArrayList getSupplyList() {
0903: waitForFinalize();
0904: return _real.getSupplyList();
0905: }
0906:
0907: public Schedule getBufferedCritLevels() {
0908: waitForFinalize();
0909: return _real.getBufferedCritLevels();
0910: }
0911:
0912: public Schedule getBufferedInvLevels() {
0913: waitForFinalize();
0914: return _real.getBufferedInvLevels();
0915: }
0916:
0917: public Schedule getBufferedTargetLevels() {
0918: waitForFinalize();
0919: return _real.getBufferedTargetLevels();
0920: }
0921:
0922: public ArrayList getActualDemandTasksList() {
0923: waitForFinalize();
0924: return _real.getActualDemandTasksList();
0925: }
0926:
0927: public long getEffectiveProjectionStart(Task task, long start) {
0928: waitForFinalize();
0929: return _real.getEffectiveProjectionStart(task, start);
0930: }
0931:
0932: public void reinitialize(boolean logToCSV,
0933: InventoryManager parentPlugin) {
0934: waitForFinalize();
0935: _real.reinitialize(logToCSV, parentPlugin);
0936: }
0937:
0938: public void clearTargetLevels(int startBucket) {
0939: waitForFinalize();
0940: _real.clearTargetLevels(startBucket);
0941: }
0942:
0943: public void recalculateInitialLevel() {
0944: waitForFinalize();
0945: _real.recalculateInitialLevel();
0946: }
0947:
0948: public ShortfallInventory checkForShortfall(String invID,
0949: String unitOfIssue) {
0950: waitForFinalize();
0951: return _real.checkForShortfall(invID, unitOfIssue);
0952: }
0953:
0954: public String getItemName() {
0955: waitForFinalize();
0956: return _real.getItemName();
0957: }
0958:
0959: public Object clone() throws CloneNotSupportedException {
0960: throw new CloneNotSupportedException();
0961: }
0962:
0963: public NewPropertyGroup unlock(Object key) {
0964: return null;
0965: }
0966:
0967: public PropertyGroup lock(Object key) {
0968: return null;
0969: }
0970:
0971: public PropertyGroup lock() {
0972: return null;
0973: }
0974:
0975: public PropertyGroup copy() {
0976: return null;
0977: }
0978:
0979: public Class getPrimaryClass() {
0980: return primaryClass;
0981: }
0982:
0983: public String getAssetGetMethod() {
0984: return assetGetter;
0985: }
0986:
0987: public String getAssetSetMethod() {
0988: return assetSetter;
0989: }
0990:
0991: public Class getIntrospectionClass() {
0992: return LogisticsInventoryPGImpl.class;
0993: }
0994:
0995: public synchronized boolean hasDataQuality() {
0996: return (_real != null) && _real.hasDataQuality();
0997: }
0998:
0999: public synchronized org.cougaar.planning.ldm.dq.DataQuality getDataQuality() {
1000: return (_real == null) ? null : (_real.getDataQuality());
1001: }
1002:
1003: // Finalization support
1004: private LogisticsInventoryPG _real = null;
1005:
1006: public synchronized void finalize(PropertyGroup real) {
1007: if (real instanceof LogisticsInventoryPG) {
1008: _real = (LogisticsInventoryPG) real;
1009: notifyAll();
1010: } else {
1011: throw new IllegalArgumentException(
1012: "Finalization with wrong class: " + real);
1013: }
1014: }
1015:
1016: private synchronized void waitForFinalize() {
1017: while (_real == null) {
1018: try {
1019: wait();
1020: } catch (InterruptedException _ie) {
1021: // We should really let waitForFinalize throw InterruptedException
1022: Thread.interrupted();
1023: }
1024: }
1025: }
1026: }
1027: }
|