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: package org.cougaar.planning.ldm.plan;
028:
029: import java.beans.IntrospectionException;
030: import java.beans.PropertyDescriptor;
031: import java.io.IOException;
032: import java.io.ObjectInputStream;
033: import java.io.ObjectOutputStream;
034: import java.util.Collection;
035: import java.util.Enumeration;
036: import java.util.List;
037: import java.util.ListIterator;
038:
039: import org.cougaar.core.blackboard.Blackboard;
040: import org.cougaar.core.blackboard.Subscriber;
041:
042: /** AggregationImpl.java
043: * Implementation for aggregation
044: */
045:
046: public class AggregationImpl extends PlanElementImpl implements
047: Aggregation {
048:
049: private transient Composition comp; // changed to transient : Persistence
050:
051: public AggregationImpl() {
052: }
053:
054: /* Constructor that takes the composition and
055: * assumes that there was no estimate.
056: * @param p Plan
057: * @param t Task
058: * @param composition
059: * @return Aggregation
060: */
061: public AggregationImpl(Plan p, Task t, Composition composition) {
062: super (p, t);
063: this .comp = composition;
064: }
065:
066: /* Constructor that takes the composition and an estimated result
067: * @param t
068: * @param p
069: * @param composition
070: * @param estimatedresult
071: * @return Aggregation
072: */
073: public AggregationImpl(Plan p, Task t, Composition composition,
074: AllocationResult estimatedresult) {
075: super (p, t);
076: this .comp = composition;
077: this .estAR = estimatedresult;
078: }
079:
080: /** Returns the Composition created by the aggregations of the task.
081: * @see org.cougaar.planning.ldm.plan.Composition
082: * @return Composition
083: **/
084: public Composition getComposition() {
085: return comp;
086: }
087:
088: private void writeObject(ObjectOutputStream stream)
089: throws IOException {
090: stream.defaultWriteObject();
091: stream.writeObject(comp);
092: }
093:
094: private void readObject(ObjectInputStream stream)
095: throws ClassNotFoundException, IOException {
096: /** ----------
097: * READ handlers common to Persistence and
098: * Network serialization. NOte that these
099: * cannot be references to Persistable objects.
100: * defaultReadObject() is likely to belong here...
101: * ---------- **/
102: stream.defaultReadObject();
103:
104: comp = (Composition) stream.readObject();
105: }
106:
107: public String toString() {
108: return "[Aggregation of " + getTask().getUID() + " to " + comp
109: + "]";
110: }
111:
112: // ActiveSubscription code
113: // override PlanElementImpls remove stuff
114: public void removingFromBlackboard(Subscriber s, boolean commit) {
115: Blackboard.getTracker().checkpoint(commit, getTask(),
116: "getPlanElement");
117: if (!commit)
118: return;
119:
120: Task t = getTask();
121: ((TaskImpl) t).privately_resetPlanElement();
122: Composition c = getComposition();
123:
124: if (c == null)
125: return; // if already disconnected...
126:
127: if (c.isPropagating()) { // if we're auto-propagating
128: CompositionImpl ci = (CompositionImpl) c;
129:
130: // check to make sure we haven't already done the mass cleanup
131: if (ci.doingCleanUp()) { // atomic check and clear
132: // since we will get "notified" for every aggregation we rescinded
133: // during the mass cleanup
134: // rescind every aggregation planelement associated with the composition
135:
136: List aggpes = ci.clearAggregations(); // atomic get and clear the list
137: ListIterator it = aggpes.listIterator();
138: while (it.hasNext()) {
139: Aggregation anagg = (Aggregation) it.next();
140: if (anagg != this ) { // dont recurse on ourselves...
141: Task atask = anagg.getTask();
142: s.publishRemove(anagg);
143: s.publishChange(atask);
144: }
145: }
146:
147: // rescind the combined task
148: s.publishRemove(c.getCombinedTask());
149: }
150: } else { // we're not auto-propagating
151: // clean up the references to this pe and its task in
152: // the composition and the combined MPTask
153: ((CompositionImpl) c).removeAggregation(this );
154: MPTask combtask = (MPTask) c.getCombinedTask();
155: ((MPTaskImpl) combtask).removeParentTask(t);
156: // if this happens to be the last parent of this combined task
157: // rescind the combined task since its no longer valid.
158: Enumeration parentsleft = combtask.getParentTasks();
159: if (!parentsleft.hasMoreElements()) {
160: s.publishRemove(combtask);
161: }
162: }
163: }
164:
165: // beaninfo
166: protected void addPropertyDescriptors(Collection c)
167: throws IntrospectionException {
168: super .addPropertyDescriptors(c);
169: c.add(new PropertyDescriptor("composition",
170: AggregationImpl.class, "getComposition", null));
171: }
172: }
|