001: /*
002: * <copyright>
003: *
004: * Copyright 1997-2004 BBNT Solutions, LLC
005: * under sponsorship of the Defense Advanced Research Projects
006: * Agency (DARPA).
007: *
008: * You can redistribute this software and/or modify it under the
009: * terms of the Cougaar Open Source License as published on the
010: * Cougaar Open Source Website (www.cougaar.org).
011: *
012: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
013: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
014: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
015: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
016: * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
017: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
018: * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
019: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
020: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
021: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
022: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
023: *
024: * </copyright>
025: */
026:
027: /* @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 */
028: /** Implementation of InventoryPG.
029: * @see InventoryPG
030: * @see NewInventoryPG
031: **/package org.cougaar.glm.ldm.asset;
032:
033: import org.cougaar.planning.ldm.measure.*;
034: import org.cougaar.planning.ldm.asset.*;
035: import org.cougaar.planning.ldm.plan.*;
036: import java.util.*;
037:
038: import org.cougaar.glm.ldm.plan.*;
039: import org.cougaar.glm.ldm.oplan.*;
040: import org.cougaar.glm.ldm.policy.*;
041: import org.cougaar.core.mts.MessageAddress;
042: import org.cougaar.glm.execution.common.InventoryReport;
043:
044: import java.io.ObjectOutputStream;
045: import java.io.ObjectInputStream;
046: import java.io.IOException;
047: import java.beans.PropertyDescriptor;
048: import java.beans.IndexedPropertyDescriptor;
049:
050: public class InventoryPGImpl extends java.beans.SimpleBeanInfo
051: implements NewInventoryPG, Cloneable {
052: public InventoryPGImpl() {
053: }
054:
055: // Slots
056:
057: private Scalar theCapacity;
058:
059: public Scalar getCapacity() {
060: return theCapacity;
061: }
062:
063: public void setCapacity(Scalar capacity) {
064: theCapacity = capacity;
065: }
066:
067: private Scalar theInitialLevel;
068:
069: public Scalar getInitialLevel() {
070: return theInitialLevel;
071: }
072:
073: public void setInitialLevel(Scalar initialLevel) {
074: theInitialLevel = initialLevel;
075: }
076:
077: private Scalar theReorderLevel;
078:
079: public Scalar getReorderLevel() {
080: return theReorderLevel;
081: }
082:
083: public void setReorderLevel(Scalar reorderLevel) {
084: theReorderLevel = reorderLevel;
085: }
086:
087: private Scalar theMinReorder;
088:
089: public Scalar getMinReorder() {
090: return theMinReorder;
091: }
092:
093: public void setMinReorder(Scalar minReorder) {
094: theMinReorder = minReorder;
095: }
096:
097: private Scalar theUnobtainable;
098:
099: public Scalar getUnobtainable() {
100: return theUnobtainable;
101: }
102:
103: public void setUnobtainable(Scalar unobtainable) {
104: theUnobtainable = unobtainable;
105: }
106:
107: private boolean theFillToCapacity;
108:
109: public boolean getFillToCapacity() {
110: return theFillToCapacity;
111: }
112:
113: public void setFillToCapacity(boolean fillToCapacity) {
114: theFillToCapacity = fillToCapacity;
115: }
116:
117: private boolean theMaintainAtCapacity;
118:
119: public boolean getMaintainAtCapacity() {
120: return theMaintainAtCapacity;
121: }
122:
123: public void setMaintainAtCapacity(boolean maintainAtCapacity) {
124: theMaintainAtCapacity = maintainAtCapacity;
125: }
126:
127: private Asset theResource;
128:
129: public Asset getResource() {
130: return theResource;
131: }
132:
133: public void setResource(Asset resource) {
134: theResource = resource;
135: }
136:
137: private InventoryBG invBG = null;
138:
139: public InventoryBG getInvBG() {
140: return invBG;
141: }
142:
143: public void setInvBG(InventoryBG _invBG) {
144: if (invBG != null)
145: throw new IllegalArgumentException("invBG already set");
146: invBG = _invBG;
147: }
148:
149: public int resetInventory(Inventory inventory, long today) {
150: return invBG.resetInventory(inventory, today);
151: }
152:
153: public int getToday() {
154: return invBG.getToday();
155: }
156:
157: public int getFirstPlanningDay() {
158: return invBG.getFirstPlanningDay();
159: }
160:
161: public Scalar getLevel(long day) {
162: return invBG.getLevel(day);
163: }
164:
165: public Scalar getLevel(int day) {
166: return invBG.getLevel(day);
167: }
168:
169: public int withdrawFromInventory(Inventory inventory,
170: MessageAddress cluster) {
171: return invBG.withdrawFromInventory(inventory, cluster);
172: }
173:
174: public double getNDaysDemand(int day) {
175: return invBG.getNDaysDemand(day);
176: }
177:
178: public double getReorderLevel(int day) {
179: return invBG.getReorderLevel(day);
180: }
181:
182: public double getGoalLevel(int day) {
183: return invBG.getGoalLevel(day);
184: }
185:
186: public int addPreviousRefillsToInventory(Task maintainInv) {
187: return invBG.addPreviousRefillsToInventory(maintainInv);
188: }
189:
190: public int addDueIn(Task refillTask) {
191: return invBG.addDueIn(refillTask);
192: }
193:
194: public int removeDueIn(Task refillTask) {
195: return invBG.removeDueIn(refillTask);
196: }
197:
198: public int getPlanningDays() {
199: return invBG.getPlanningDays();
200: }
201:
202: public void computeThresholdSchedule(int daysOfDemand,
203: int daysForward, int daysBackward, double minReorderLevel,
204: double maxReorderLevel, double goalLevelMultiplier) {
205: invBG.computeThresholdSchedule(daysOfDemand, daysForward,
206: daysBackward, minReorderLevel, maxReorderLevel,
207: goalLevelMultiplier);
208: }
209:
210: public int determineInventoryLevels() {
211: return invBG.determineInventoryLevels();
212: }
213:
214: public Task refillAlreadyFailedOnDay(int day) {
215: return invBG.refillAlreadyFailedOnDay(day);
216: }
217:
218: public Task getRefillOnDay(int day) {
219: return invBG.getRefillOnDay(day);
220: }
221:
222: public void removeRefillProjection(int day) {
223: invBG.removeRefillProjection(day);
224: }
225:
226: public Scalar getProjected(int day) {
227: return invBG.getProjected(day);
228: }
229:
230: public Scalar getProjectedRefill(int day) {
231: return invBG.getProjectedRefill(day);
232: }
233:
234: public Date lastDemandTaskEnd(Inventory inventory) {
235: return invBG.lastDemandTaskEnd(inventory);
236: }
237:
238: public Integer getFirstOverflow(int day, MessageAddress cluster) {
239: return invBG.getFirstOverflow(day, cluster);
240: }
241:
242: public DueOut getLowestPriorityDueOutBeforeDay(int end) {
243: return invBG.getLowestPriorityDueOutBeforeDay(end);
244: }
245:
246: public List updateDueOutAllocations() {
247: return invBG.updateDueOutAllocations();
248: }
249:
250: public int updateContentSchedule(Inventory inventory) {
251: return invBG.updateContentSchedule(inventory);
252: }
253:
254: public int updateDetailedContentSchedule(Inventory inventory) {
255: return invBG.updateDetailedContentSchedule(inventory);
256: }
257:
258: public int clearContentSchedule(Inventory inventory) {
259: return invBG.clearContentSchedule(inventory);
260: }
261:
262: public int updateInventoryLevelsSchedule(Inventory inventory) {
263: return invBG.updateInventoryLevelsSchedule(inventory);
264: }
265:
266: public int clearInventoryLevelsSchedule(Inventory inventory) {
267: return invBG.clearInventoryLevelsSchedule(inventory);
268: }
269:
270: public int printQuantityScheduleTimes(Schedule sched) {
271: return invBG.printQuantityScheduleTimes(sched);
272: }
273:
274: public int printInventoryLevels(Inventory inventory,
275: MessageAddress clusterID) {
276: return invBG.printInventoryLevels(inventory, clusterID);
277: }
278:
279: public PGDelegate copy(PropertyGroup pg) {
280: return invBG.copy(pg);
281: }
282:
283: public Enumeration getAllDueIns() {
284: return invBG.getAllDueIns();
285: }
286:
287: public ProjectionWeight getProjectionWeight() {
288: return invBG.getProjectionWeight();
289: }
290:
291: public void setProjectionWeight(ProjectionWeight newWeight) {
292: invBG.setProjectionWeight(newWeight);
293: }
294:
295: public void addInventoryReport(InventoryReport anInventoryReport) {
296: invBG.addInventoryReport(anInventoryReport);
297: }
298:
299: public InventoryReport getLatestInventoryReport() {
300: return invBG.getLatestInventoryReport();
301: }
302:
303: public InventoryReport getOldestInventoryReport() {
304: return invBG.getOldestInventoryReport();
305: }
306:
307: public void pruneOldInventoryReports(long pruneTime) {
308: invBG.pruneOldInventoryReports(pruneTime);
309: }
310:
311: public long convertDayToTime(int day) {
312: return invBG.convertDayToTime(day);
313: }
314:
315: public long getStartOfDay(int day) {
316: return invBG.getStartOfDay(day);
317: }
318:
319: public int convertTimeToDay(long time) {
320: return invBG.convertTimeToDay(time);
321: }
322:
323: public int getImputedDayOfTime(long time) {
324: return invBG.getImputedDayOfTime(time);
325: }
326:
327: public int getImputedDay(int day) {
328: return invBG.getImputedDay(day);
329: }
330:
331: public void setDueOutFilled(DueOut dueOut, boolean newFilled) {
332: invBG.setDueOutFilled(dueOut, newFilled);
333: }
334:
335: public InventoryPGImpl(InventoryPG original) {
336: theCapacity = original.getCapacity();
337: theInitialLevel = original.getInitialLevel();
338: theReorderLevel = original.getReorderLevel();
339: theMinReorder = original.getMinReorder();
340: theUnobtainable = original.getUnobtainable();
341: theFillToCapacity = original.getFillToCapacity();
342: theMaintainAtCapacity = original.getMaintainAtCapacity();
343: theResource = original.getResource();
344: }
345:
346: public boolean equals(Object other) {
347:
348: if (!(other instanceof InventoryPG)) {
349: return false;
350: }
351:
352: InventoryPG otherInventoryPG = (InventoryPG) other;
353:
354: if (getCapacity() == null) {
355: if (otherInventoryPG.getCapacity() != null) {
356: return false;
357: }
358: } else if (!(getCapacity().equals(otherInventoryPG
359: .getCapacity()))) {
360: return false;
361: }
362:
363: if (getInitialLevel() == null) {
364: if (otherInventoryPG.getInitialLevel() != null) {
365: return false;
366: }
367: } else if (!(getInitialLevel().equals(otherInventoryPG
368: .getInitialLevel()))) {
369: return false;
370: }
371:
372: if (getReorderLevel() == null) {
373: if (otherInventoryPG.getReorderLevel() != null) {
374: return false;
375: }
376: } else if (!(getReorderLevel().equals(otherInventoryPG
377: .getReorderLevel()))) {
378: return false;
379: }
380:
381: if (getMinReorder() == null) {
382: if (otherInventoryPG.getMinReorder() != null) {
383: return false;
384: }
385: } else if (!(getMinReorder().equals(otherInventoryPG
386: .getMinReorder()))) {
387: return false;
388: }
389:
390: if (getUnobtainable() == null) {
391: if (otherInventoryPG.getUnobtainable() != null) {
392: return false;
393: }
394: } else if (!(getUnobtainable().equals(otherInventoryPG
395: .getUnobtainable()))) {
396: return false;
397: }
398:
399: if (!(getFillToCapacity() == otherInventoryPG
400: .getFillToCapacity())) {
401: return false;
402: }
403:
404: if (!(getMaintainAtCapacity() == otherInventoryPG
405: .getMaintainAtCapacity())) {
406: return false;
407: }
408:
409: if (getResource() == null) {
410: if (otherInventoryPG.getResource() != null) {
411: return false;
412: }
413: } else if (!(getResource().equals(otherInventoryPG
414: .getResource()))) {
415: return false;
416: }
417:
418: if (other instanceof InventoryPGImpl) {
419: if (getInvBG() == null) {
420: if (((InventoryPGImpl) otherInventoryPG).getInvBG() != null) {
421: return false;
422: }
423: } else if (!(getInvBG()
424: .equals(((InventoryPGImpl) otherInventoryPG)
425: .getInvBG()))) {
426: return false;
427: }
428:
429: }
430: return true;
431: }
432:
433: public boolean hasDataQuality() {
434: return false;
435: }
436:
437: public org.cougaar.planning.ldm.dq.DataQuality getDataQuality() {
438: return null;
439: }
440:
441: // static inner extension class for real DataQuality Support
442: public final static class DQ extends InventoryPGImpl implements
443: org.cougaar.planning.ldm.dq.NewHasDataQuality {
444: public DQ() {
445: super ();
446: }
447:
448: public DQ(InventoryPG original) {
449: super (original);
450: }
451:
452: public Object clone() {
453: return new DQ(this );
454: }
455:
456: private transient org.cougaar.planning.ldm.dq.DataQuality _dq = null;
457:
458: public boolean hasDataQuality() {
459: return (_dq != null);
460: }
461:
462: public org.cougaar.planning.ldm.dq.DataQuality getDataQuality() {
463: return _dq;
464: }
465:
466: public void setDataQuality(
467: org.cougaar.planning.ldm.dq.DataQuality dq) {
468: _dq = dq;
469: }
470:
471: private void writeObject(ObjectOutputStream out)
472: throws IOException {
473: out.defaultWriteObject();
474: if (out instanceof org.cougaar.core.persist.PersistenceOutputStream)
475: out.writeObject(_dq);
476: }
477:
478: private void readObject(ObjectInputStream in)
479: throws ClassNotFoundException, IOException {
480: in.defaultReadObject();
481: if (in instanceof org.cougaar.core.persist.PersistenceInputStream)
482: _dq = (org.cougaar.planning.ldm.dq.DataQuality) in
483: .readObject();
484: }
485:
486: private final static PropertyDescriptor properties[] = new PropertyDescriptor[1];
487: static {
488: try {
489: properties[0] = new PropertyDescriptor("dataQuality",
490: DQ.class, "getDataQuality", null);
491: } catch (Exception e) {
492: e.printStackTrace();
493: }
494: }
495:
496: public PropertyDescriptor[] getPropertyDescriptors() {
497: PropertyDescriptor[] pds = super .properties;
498: PropertyDescriptor[] ps = new PropertyDescriptor[pds.length
499: + properties.length];
500: System.arraycopy(pds, 0, ps, 0, pds.length);
501: System.arraycopy(properties, 0, ps, pds.length,
502: properties.length);
503: return ps;
504: }
505: }
506:
507: private transient InventoryPG _locked = null;
508:
509: public PropertyGroup lock(Object key) {
510: if (_locked == null)
511: _locked = new _Locked(key);
512: return _locked;
513: }
514:
515: public PropertyGroup lock() {
516: return lock(null);
517: }
518:
519: public NewPropertyGroup unlock(Object key) {
520: return this ;
521: }
522:
523: public Object clone() throws CloneNotSupportedException {
524: InventoryPGImpl _tmp = new InventoryPGImpl(this );
525: if (invBG != null) {
526: _tmp.invBG = (InventoryBG) invBG.copy(_tmp);
527: }
528: return _tmp;
529: }
530:
531: public PropertyGroup copy() {
532: try {
533: return (PropertyGroup) clone();
534: } catch (CloneNotSupportedException cnse) {
535: return null;
536: }
537: }
538:
539: public Class getPrimaryClass() {
540: return primaryClass;
541: }
542:
543: public String getAssetGetMethod() {
544: return assetGetter;
545: }
546:
547: public String getAssetSetMethod() {
548: return assetSetter;
549: }
550:
551: private final static PropertyDescriptor properties[] = new PropertyDescriptor[8];
552: static {
553: try {
554: properties[0] = new PropertyDescriptor("capacity",
555: InventoryPG.class, "getCapacity", null);
556: properties[1] = new PropertyDescriptor("initialLevel",
557: InventoryPG.class, "getInitialLevel", null);
558: properties[2] = new PropertyDescriptor("reorderLevel",
559: InventoryPG.class, "getReorderLevel", null);
560: properties[3] = new PropertyDescriptor("minReorder",
561: InventoryPG.class, "getMinReorder", null);
562: properties[4] = new PropertyDescriptor("unobtainable",
563: InventoryPG.class, "getUnobtainable", null);
564: properties[5] = new PropertyDescriptor("fillToCapacity",
565: InventoryPG.class, "getFillToCapacity", null);
566: properties[6] = new PropertyDescriptor(
567: "maintainAtCapacity", InventoryPG.class,
568: "getMaintainAtCapacity", null);
569: properties[7] = new PropertyDescriptor("resource",
570: InventoryPG.class, "getResource", null);
571: } catch (Exception e) {
572: org.cougaar.util.log.Logging.getLogger(InventoryPG.class)
573: .error("Caught exception", e);
574: }
575: }
576:
577: public PropertyDescriptor[] getPropertyDescriptors() {
578: return properties;
579: }
580:
581: private final class _Locked extends java.beans.SimpleBeanInfo
582: implements InventoryPG, Cloneable, LockedPG {
583: private transient Object theKey = null;
584:
585: _Locked(Object key) {
586: if (this .theKey == null)
587: this .theKey = key;
588: }
589:
590: public _Locked() {
591: }
592:
593: public PropertyGroup lock() {
594: return this ;
595: }
596:
597: public PropertyGroup lock(Object o) {
598: return this ;
599: }
600:
601: public NewPropertyGroup unlock(Object key)
602: throws IllegalAccessException {
603: if (theKey.equals(key)) {
604: return InventoryPGImpl.this ;
605: } else {
606: throw new IllegalAccessException(
607: "unlock: mismatched internal and provided keys!");
608: }
609: }
610:
611: public PropertyGroup copy() {
612: try {
613: return (PropertyGroup) clone();
614: } catch (CloneNotSupportedException cnse) {
615: return null;
616: }
617: }
618:
619: public Object clone() throws CloneNotSupportedException {
620: InventoryPGImpl _tmp = new InventoryPGImpl(this );
621: if (invBG != null) {
622: _tmp.invBG = (InventoryBG) invBG.copy(_tmp);
623: }
624: return _tmp;
625: }
626:
627: public boolean equals(Object object) {
628: return InventoryPGImpl.this .equals(object);
629: }
630:
631: public Scalar getCapacity() {
632: return InventoryPGImpl.this .getCapacity();
633: }
634:
635: public Scalar getInitialLevel() {
636: return InventoryPGImpl.this .getInitialLevel();
637: }
638:
639: public Scalar getReorderLevel() {
640: return InventoryPGImpl.this .getReorderLevel();
641: }
642:
643: public Scalar getMinReorder() {
644: return InventoryPGImpl.this .getMinReorder();
645: }
646:
647: public Scalar getUnobtainable() {
648: return InventoryPGImpl.this .getUnobtainable();
649: }
650:
651: public boolean getFillToCapacity() {
652: return InventoryPGImpl.this .getFillToCapacity();
653: }
654:
655: public boolean getMaintainAtCapacity() {
656: return InventoryPGImpl.this .getMaintainAtCapacity();
657: }
658:
659: public Asset getResource() {
660: return InventoryPGImpl.this .getResource();
661: }
662:
663: public int resetInventory(Inventory inventory, long today) {
664: return InventoryPGImpl.this
665: .resetInventory(inventory, today);
666: }
667:
668: public int getToday() {
669: return InventoryPGImpl.this .getToday();
670: }
671:
672: public int getFirstPlanningDay() {
673: return InventoryPGImpl.this .getFirstPlanningDay();
674: }
675:
676: public Scalar getLevel(long day) {
677: return InventoryPGImpl.this .getLevel(day);
678: }
679:
680: public Scalar getLevel(int day) {
681: return InventoryPGImpl.this .getLevel(day);
682: }
683:
684: public int withdrawFromInventory(Inventory inventory,
685: MessageAddress cluster) {
686: return InventoryPGImpl.this .withdrawFromInventory(
687: inventory, cluster);
688: }
689:
690: public double getNDaysDemand(int day) {
691: return InventoryPGImpl.this .getNDaysDemand(day);
692: }
693:
694: public double getReorderLevel(int day) {
695: return InventoryPGImpl.this .getReorderLevel(day);
696: }
697:
698: public double getGoalLevel(int day) {
699: return InventoryPGImpl.this .getGoalLevel(day);
700: }
701:
702: public int addPreviousRefillsToInventory(Task maintainInv) {
703: return InventoryPGImpl.this
704: .addPreviousRefillsToInventory(maintainInv);
705: }
706:
707: public int addDueIn(Task refillTask) {
708: return InventoryPGImpl.this .addDueIn(refillTask);
709: }
710:
711: public int removeDueIn(Task refillTask) {
712: return InventoryPGImpl.this .removeDueIn(refillTask);
713: }
714:
715: public int getPlanningDays() {
716: return InventoryPGImpl.this .getPlanningDays();
717: }
718:
719: public void computeThresholdSchedule(int daysOfDemand,
720: int daysForward, int daysBackward,
721: double minReorderLevel, double maxReorderLevel,
722: double goalLevelMultiplier) {
723: InventoryPGImpl.this .computeThresholdSchedule(daysOfDemand,
724: daysForward, daysBackward, minReorderLevel,
725: maxReorderLevel, goalLevelMultiplier);
726: }
727:
728: public int determineInventoryLevels() {
729: return InventoryPGImpl.this .determineInventoryLevels();
730: }
731:
732: public Task refillAlreadyFailedOnDay(int day) {
733: return InventoryPGImpl.this .refillAlreadyFailedOnDay(day);
734: }
735:
736: public Task getRefillOnDay(int day) {
737: return InventoryPGImpl.this .getRefillOnDay(day);
738: }
739:
740: public void removeRefillProjection(int day) {
741: InventoryPGImpl.this .removeRefillProjection(day);
742: }
743:
744: public Scalar getProjected(int day) {
745: return InventoryPGImpl.this .getProjected(day);
746: }
747:
748: public Scalar getProjectedRefill(int day) {
749: return InventoryPGImpl.this .getProjectedRefill(day);
750: }
751:
752: public Date lastDemandTaskEnd(Inventory inventory) {
753: return InventoryPGImpl.this .lastDemandTaskEnd(inventory);
754: }
755:
756: public Integer getFirstOverflow(int day, MessageAddress cluster) {
757: return InventoryPGImpl.this .getFirstOverflow(day, cluster);
758: }
759:
760: public DueOut getLowestPriorityDueOutBeforeDay(int end) {
761: return InventoryPGImpl.this
762: .getLowestPriorityDueOutBeforeDay(end);
763: }
764:
765: public List updateDueOutAllocations() {
766: return InventoryPGImpl.this .updateDueOutAllocations();
767: }
768:
769: public int updateContentSchedule(Inventory inventory) {
770: return InventoryPGImpl.this
771: .updateContentSchedule(inventory);
772: }
773:
774: public int updateDetailedContentSchedule(Inventory inventory) {
775: return InventoryPGImpl.this
776: .updateDetailedContentSchedule(inventory);
777: }
778:
779: public int clearContentSchedule(Inventory inventory) {
780: return InventoryPGImpl.this .clearContentSchedule(inventory);
781: }
782:
783: public int updateInventoryLevelsSchedule(Inventory inventory) {
784: return InventoryPGImpl.this
785: .updateInventoryLevelsSchedule(inventory);
786: }
787:
788: public int clearInventoryLevelsSchedule(Inventory inventory) {
789: return InventoryPGImpl.this
790: .clearInventoryLevelsSchedule(inventory);
791: }
792:
793: public int printQuantityScheduleTimes(Schedule sched) {
794: return InventoryPGImpl.this
795: .printQuantityScheduleTimes(sched);
796: }
797:
798: public int printInventoryLevels(Inventory inventory,
799: MessageAddress clusterID) {
800: return InventoryPGImpl.this .printInventoryLevels(inventory,
801: clusterID);
802: }
803:
804: public PGDelegate copy(PropertyGroup pg) {
805: return InventoryPGImpl.this .copy(pg);
806: }
807:
808: public Enumeration getAllDueIns() {
809: return InventoryPGImpl.this .getAllDueIns();
810: }
811:
812: public ProjectionWeight getProjectionWeight() {
813: return InventoryPGImpl.this .getProjectionWeight();
814: }
815:
816: public void setProjectionWeight(ProjectionWeight newWeight) {
817: InventoryPGImpl.this .setProjectionWeight(newWeight);
818: }
819:
820: public void addInventoryReport(InventoryReport anInventoryReport) {
821: InventoryPGImpl.this .addInventoryReport(anInventoryReport);
822: }
823:
824: public InventoryReport getLatestInventoryReport() {
825: return InventoryPGImpl.this .getLatestInventoryReport();
826: }
827:
828: public InventoryReport getOldestInventoryReport() {
829: return InventoryPGImpl.this .getOldestInventoryReport();
830: }
831:
832: public void pruneOldInventoryReports(long pruneTime) {
833: InventoryPGImpl.this .pruneOldInventoryReports(pruneTime);
834: }
835:
836: public long convertDayToTime(int day) {
837: return InventoryPGImpl.this .convertDayToTime(day);
838: }
839:
840: public long getStartOfDay(int day) {
841: return InventoryPGImpl.this .getStartOfDay(day);
842: }
843:
844: public int convertTimeToDay(long time) {
845: return InventoryPGImpl.this .convertTimeToDay(time);
846: }
847:
848: public int getImputedDayOfTime(long time) {
849: return InventoryPGImpl.this .getImputedDayOfTime(time);
850: }
851:
852: public int getImputedDay(int day) {
853: return InventoryPGImpl.this .getImputedDay(day);
854: }
855:
856: public void setDueOutFilled(DueOut dueOut, boolean newFilled) {
857: InventoryPGImpl.this .setDueOutFilled(dueOut, newFilled);
858: }
859:
860: public final boolean hasDataQuality() {
861: return InventoryPGImpl.this .hasDataQuality();
862: }
863:
864: public final org.cougaar.planning.ldm.dq.DataQuality getDataQuality() {
865: return InventoryPGImpl.this .getDataQuality();
866: }
867:
868: public Class getPrimaryClass() {
869: return primaryClass;
870: }
871:
872: public String getAssetGetMethod() {
873: return assetGetter;
874: }
875:
876: public String getAssetSetMethod() {
877: return assetSetter;
878: }
879:
880: public PropertyDescriptor[] getPropertyDescriptors() {
881: return properties;
882: }
883:
884: public Class getIntrospectionClass() {
885: return InventoryPGImpl.class;
886: }
887:
888: }
889:
890: }
|