/*
* public HashMap getLeafElements() { HashMap map = new HashMap(); Object[]
* elts = dataElements.values().toArray(); for (int j=0; j<elts.length; j++)
* { PDMDataElement data = (PDMDataElement) elts[j];
* map.put(data.getID(),data); } Object[] ops =
* operations.values().toArray(); for (int i=0; i<ops.length; i++){
* PDMOperation op = (PDMOperation) ops[i]; if
* (!(op.getInputElements().isEmpty())){ HashMap outs =
* op.getOutputElements(); Object[] outArray = outs.values().toArray(); for
* (int j=0; j<outArray.length; j++) { PDMDataElement d = (PDMDataElement)
* outArray[j]; map.remove(d.getID()); } } } return map; }
*/
public HashMap getLeafElements() {
HashMap result = new HashMap();
HashSet leafOps = getLeafOperations();
if (!(leafOps.isEmpty())) {
Iterator it = leafOps.iterator();
while (it.hasNext()) {
PDMOperation op = (PDMOperation) it.next();
PDMDataElement data = op.getOutputElement();
result.put(data.getID(), data);
}
} else {
Object[] elts = dataElements.values().toArray();
for (int j = 0; j < elts.length; j++) {
PDMDataElement data = (PDMDataElement) elts[j];
result.put(data.getID(), data);
}
Object[] ops = operations.values().toArray();
for (int i = 0; i < ops.length; i++) {
PDMOperation op = (PDMOperation) ops[i];
HashMap outs = op.getOutputElements();
Object[] outArray = outs.values().toArray();
for (int j = 0; j < outArray.length; j++) {
PDMDataElement d = (PDMDataElement) outArray[j];
result.remove(d.getID());
}
}
}
return result;
}
public synchronized void messageReceived(int to, Message m) {
DrainMsg mhMsg = (DrainMsg) m;
log.debug(
"incoming: localDest: "
+ to
+ " type:"
+ mhMsg.get_type()
+ " hops:"
+ (16 - mhMsg.get_ttl())
+ " seqNo:"
+ mhMsg.get_seqNo()
+ " source:"
+ mhMsg.get_source()
+ " finalDest:"
+ mhMsg.get_dest());
// lets assume that the network cannot buffer more than 25 drain msgs from a single source at a
// time (should be more than reasonable)
if (seqNos.containsKey(new Integer(mhMsg.get_source()))) {
int oldSeqNo = ((Integer) seqNos.get(new Integer(mhMsg.get_source()))).intValue();
int upperBound = mhMsg.get_seqNo() + 25;
int wrappedUpperBound = 25 - (255 - mhMsg.get_seqNo());
if ((oldSeqNo >= mhMsg.get_seqNo() && oldSeqNo < upperBound)
|| (oldSeqNo >= 0 && oldSeqNo < wrappedUpperBound)) {
log.debug(
"Dropping message from "
+ mhMsg.get_source()
+ " with duplicate seqNo: "
+ mhMsg.get_seqNo());
return;
}
}
seqNos.put(new Integer(mhMsg.get_source()), new Integer(mhMsg.get_seqNo()));
if (to != spAddr && to != MoteIF.TOS_BCAST_ADDR && to != TOS_UART_ADDR) {
log.debug("Dropping message not for me.");
return;
}
HashSet promiscuousSet = (HashSet) idTable.get(new Integer(BCAST_ID));
HashSet listenerSet = (HashSet) idTable.get(new Integer(mhMsg.get_type()));
if (listenerSet != null && promiscuousSet != null) {
listenerSet.addAll(promiscuousSet);
} else if (listenerSet == null && promiscuousSet != null) {
listenerSet = promiscuousSet;
}
if (listenerSet == null) {
log.debug("No Listener for type: " + mhMsg.get_type());
return;
}
for (Iterator it = listenerSet.iterator(); it.hasNext(); ) {
MessageListener ml = (MessageListener) it.next();
ml.messageReceived(to, mhMsg);
}
}
public PDMState checkIfStateExists(
PDMStateSpace statespace, HashSet data, HashSet exec, HashSet failed) {
PDMState result = null;
boolean bool = false;
HashSet states = statespace.getStates();
Iterator it = states.iterator();
while (it.hasNext() && !bool) {
PDMState state2 = (PDMState) it.next();
boolean one = false;
boolean two = false;
boolean three = false;
HashSet data2 = state2.dataElements;
HashSet exec2 = state2.executedOperations;
HashSet failed2 = state2.failedOperations;
one = hashSetContainsSameDataElements(data, data2);
two = hashSetContainsSameOperations(exec, exec2);
three = hashSetContainsSameOperations(failed, failed2);
if (one && two && three) {
bool = true;
result = state2;
}
}
return result;
}
public static int close() {
int count = 0;
Iterator iterator = m_notUsedConnection.iterator();
while (iterator.hasNext()) {
try {
((ConnectionWrapper) iterator.next()).close();
count++;
} catch (Exception e) {
}
}
m_notUsedConnection.clear();
iterator = m_usedUsedConnection.iterator();
while (iterator.hasNext()) {
try {
ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();
wrapper.close();
if (DEBUG) {
wrapper.debugInfo.printStackTrace();
}
count++;
} catch (Exception e) {
}
}
m_usedUsedConnection.clear();
return count;
}
@Override
public Iterator<Integer> getSuccessorsIterator(final int s, final int i) {
// Need to build set to avoid duplicates
// So not necessarily the fastest method to access successors
HashSet<Integer> succs = new HashSet<Integer>();
for (Distribution distr : trans.get(s).get(i)) {
succs.addAll(distr.getSupport());
}
return succs.iterator();
}
public void appendTo(Element el) {
Document doc = el.getOwnerDocument();
Element p = doc.createElement("profile");
p.setAttribute("name", name);
Iterator<String> it = ids.iterator();
while (it.hasNext()) {
Element child = doc.createElement("enable");
child.setAttribute("id", it.next());
p.appendChild(child);
}
el.appendChild(p);
}
public void testReadDictionary() {
FileResource fr = new FileResource("dictionaries/English");
HashSet<String> dict = readDictionary(fr);
System.out.println("dict has " + dict.size() + " entries");
Iterator<String> it = dict.iterator();
for (int i = 0; i < 25; i++) {
if (it.hasNext()) {
System.out.println(i + "\t" + it.next());
}
}
}
public boolean hashSetContainsSameOperations(HashSet set1, HashSet set2) {
boolean result = false;
HashSet s1 = (HashSet) set1.clone();
HashSet s2 = (HashSet) set2.clone();
// first part, are all elements of s1 also in s2?
boolean one = false;
Iterator it = set1.iterator();
while (it.hasNext()) {
PDMOperation d = (PDMOperation) it.next();
if (s2.contains(d)) {
s1.remove(d);
}
}
if (s1.isEmpty()) {
one = true;
}
// second part, are all elements of s21 also in s1?
boolean two = false;
HashSet s3 = (HashSet) set1.clone();
HashSet s4 = (HashSet) set2.clone();
Iterator it2 = set2.iterator();
while (it2.hasNext()) {
PDMOperation d = (PDMOperation) it2.next();
if (s3.contains(d)) {
s4.remove(d);
}
}
if (s4.isEmpty()) {
two = true;
}
// administrative stuff
s1.clear();
s2.clear();
s3.clear();
s4.clear();
result = one && two;
return result;
}
void remove() {
UFNode root = this.find();
if (root != this) for (UFNode child : children) child.parent = root;
else if (!children.isEmpty()) {
Iterator<UFNode> it = children.iterator();
root = it.next();
root.parent = null;
while (it.hasNext()) it.next().parent = root;
root.size = this.size;
}
root.size--;
this.parent = null;
this.size = 1;
}
public static synchronized void printDebugMsg(PrintStream out) {
if (DEBUG == false) {
return;
}
StringBuffer msg = new StringBuffer();
msg.append("debug message in " + SimpleConnectionPool.class.getName());
msg.append("\r\n");
msg.append("total count is connection pool: " + getConnectionCount());
msg.append("\r\n");
msg.append("not used connection count: " + getNotUsedConnectionCount());
msg.append("\r\n");
msg.append("used connection, count: " + getUsedConnectionCount());
out.println(msg);
Iterator iterator = m_usedUsedConnection.iterator();
while (iterator.hasNext()) {
ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();
wrapper.debugInfo.printStackTrace(out);
}
out.println();
}
/** Creates a patch from the two passed in files, writing the result to <code>os</code>. */
public static void createPatch(String oldPath, String newPath, OutputStream os, boolean minimal)
throws IOException {
JarFile2 oldJar = new JarFile2(oldPath);
JarFile2 newJar = new JarFile2(newPath);
try {
Iterator entries;
HashMap moved = new HashMap();
HashSet visited = new HashSet();
HashSet implicit = new HashSet();
HashSet moveSrc = new HashSet();
HashSet newEntries = new HashSet();
// FIRST PASS
// Go through the entries in new jar and
// determine which files are candidates for implicit moves
// ( files that has the same filename and same content in old.jar
// and new.jar )
// and for files that cannot be implicitly moved, we will either
// find out whether it is moved or new (modified)
entries = newJar.getJarEntries();
if (entries != null) {
while (entries.hasNext()) {
JarEntry newEntry = (JarEntry) entries.next();
String newname = newEntry.getName();
// Return best match of contents, will return a name match if possible
String oldname = oldJar.getBestMatch(newJar, newEntry);
if (oldname == null) {
// New or modified entry
if (_debug) {
System.out.println("NEW: " + newname);
}
newEntries.add(newname);
} else {
// Content already exist - need to do a move
// Should do implicit move? Yes, if names are the same, and
// no move command already exist from oldJar
if (oldname.equals(newname) && !moveSrc.contains(oldname)) {
if (_debug) {
System.out.println(newname + " added to implicit set!");
}
implicit.add(newname);
} else {
// The 1.0.1/1.0 JarDiffPatcher cannot handle
// multiple MOVE command with same src.
// The work around here is if we are going to generate
// a MOVE command with duplicate src, we will
// instead add the target as a new file. This way
// the jardiff can be applied by 1.0.1/1.0
// JarDiffPatcher also.
if (!minimal && (implicit.contains(oldname) || moveSrc.contains(oldname))) {
// generate non-minimal jardiff
// for backward compatibility
if (_debug) {
System.out.println("NEW: " + newname);
}
newEntries.add(newname);
} else {
// Use newname as key, since they are unique
if (_debug) {
System.err.println("moved.put " + newname + " " + oldname);
}
moved.put(newname, oldname);
moveSrc.add(oldname);
}
// Check if this disables an implicit 'move <oldname> <oldname>'
if (implicit.contains(oldname) && minimal) {
if (_debug) {
System.err.println("implicit.remove " + oldname);
System.err.println("moved.put " + oldname + " " + oldname);
}
implicit.remove(oldname);
moved.put(oldname, oldname);
moveSrc.add(oldname);
}
}
}
}
} // if (entries != null)
// SECOND PASS: <deleted files> = <oldjarnames> - <implicitmoves> -
// <source of move commands> - <new or modified entries>
ArrayList deleted = new ArrayList();
entries = oldJar.getJarEntries();
if (entries != null) {
while (entries.hasNext()) {
JarEntry oldEntry = (JarEntry) entries.next();
String oldName = oldEntry.getName();
if (!implicit.contains(oldName)
&& !moveSrc.contains(oldName)
&& !newEntries.contains(oldName)) {
if (_debug) {
System.err.println("deleted.add " + oldName);
}
deleted.add(oldName);
}
}
}
// DEBUG
if (_debug) {
// DEBUG: print out moved map
entries = moved.keySet().iterator();
if (entries != null) {
System.out.println("MOVED MAP!!!");
while (entries.hasNext()) {
String newName = (String) entries.next();
String oldName = (String) moved.get(newName);
System.out.println("key is " + newName + " value is " + oldName);
}
}
// DEBUG: print out IMOVE map
entries = implicit.iterator();
if (entries != null) {
System.out.println("IMOVE MAP!!!");
while (entries.hasNext()) {
String newName = (String) entries.next();
System.out.println("key is " + newName);
}
}
}
JarOutputStream jos = new JarOutputStream(os);
// Write out all the MOVEs and REMOVEs
createIndex(jos, deleted, moved);
// Put in New and Modified entries
entries = newEntries.iterator();
if (entries != null) {
while (entries.hasNext()) {
String newName = (String) entries.next();
if (_debug) {
System.out.println("New File: " + newName);
}
writeEntry(jos, newJar.getEntryByName(newName), newJar);
}
}
jos.finish();
jos.close();
} catch (IOException ioE) {
throw ioE;
} finally {
try {
oldJar.getJarFile().close();
} catch (IOException e1) {
// ignore
}
try {
newJar.getJarFile().close();
} catch (IOException e1) {
// ignore
}
} // finally
}
public static void main(String[] argv) {
System.out.println("StringCache Test Suite");
System.out.println("-------------------------------------------------------------");
System.out.println(" Initializing Tests");
System.out.print(" Generating string cache\t\t\t\t");
StringCache sc = new StringCache();
System.out.println("[ DONE ]");
System.out.print(" Generating random number generator\t\t\t");
RandomSource rng = new SimpleRandomSource(null);
System.out.println("[ DONE ]");
System.out.print(" Generating test strings\t\t\t\t");
char[] test = new char[] {'t', 'e', 's', 't'};
char[] test_2 = new char[] {'t', 'e', 's', 't'};
char[] test_3 = new char[] {'t', 'e', 's', 't'};
char[] test2 = new char[] {'t', 'e', 's', 't', '2'};
System.out.println("[ DONE ]");
System.out.println("-------------------------------------------------------------");
System.out.println(" Running Tests");
System.out.print(" Testing Simple Put\t\t\t\t");
String s = sc.get(test);
String s2 = sc.get(test2);
if (Arrays.equals(test, s.toCharArray())) {
System.out.println("[ PASSED ]");
} else {
System.out.println("[ FAILED ]");
System.out.println(" Input: \t" + String.valueOf(test));
System.out.println(" Output:\t" + s);
}
System.out.print(" Testing Double Put\t\t\t\t");
String s_2 = sc.get(test_2);
if (Arrays.equals(test_2, s.toCharArray()) && (s == s_2)) {
System.out.println("[ PASSED ]");
} else {
System.out.println("[ FAILED ]");
System.out.println(" Input: \t" + String.valueOf(test_2));
System.out.println(
" Output:\t" + s_2 + " " + s_2.hashCode() + " " + s + " " + s.hashCode());
}
System.out.print(" Loading 10000 4-char strings\t\t\t\t");
HashSet<String> set = new HashSet<String>();
char[] array = new char[4];
String t = null;
for (int i = 0; i < 10000; i++) {
t = sc.get(randomize(rng, array));
if (!set.contains(t)) {
set.add(t);
} else {
Iterator<String> j = set.iterator();
while (j.hasNext()) {
String other = (String) j.next();
if (other.equals(t)) {
if (other != t) {
System.out.println("[ FAILED ]");
System.out.println(
" Output:\t" + t + " " + t.hashCode() + " " + other + " " + other.hashCode());
} else {
System.out.println("MATCH! (" + t + ")");
}
}
}
}
}
System.out.println("[ PASSED ]");
System.out.println("-------------------------------------------------------------");
}
/**
* Export PDM model to Declare process model.
*
* @param bw Writer
* @throws IOException If writing fails
*/
public void writePDMToDeclare(Writer bw) throws IOException {
// write the preamble of the XML file
bw.write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n");
bw.write("<model>\n");
bw.write("<assignment language=\"ConDec\" name=\"" + name + "\">\n");
// write the activity definitions, i.e. each operation in the PDM is an
// activity definition in Declare
bw.write("<activitydefinitions>\n");
// start with an initial activity that puts the values for the leaf
// elements of the PDM
bw.write("<activity id=\"Initial\" name=\"Initial\">\n");
bw.write("<authorization/>\n");
bw.write("<datamodel>\n");
// all leaf elements
HashMap leafs = getLeafElements();
Object[] leafElts = leafs.values().toArray();
for (int i = 0; i < leafElts.length; i++) {
PDMDataElement data = (PDMDataElement) leafElts[i];
data.writePDMToDeclare(bw, "output");
}
bw.write("</datamodel>\n");
bw.write("<attributes/>\n");
bw.write("</activity>\n");
// first remove input operations from the set of operations and then
// write all real operations
HashMap realOps = (HashMap) operations.clone();
HashSet inputOps = getLeafOperations();
Iterator it7 = inputOps.iterator();
while (it7.hasNext()) {
PDMOperation op = (PDMOperation) it7.next();
realOps.remove(op.getID());
}
Iterator it4 = realOps.values().iterator();
while (it4.hasNext()) {
PDMOperation operation = (PDMOperation) it4.next();
operation.writePDMToDeclare(bw);
}
bw.write("\n");
// write all input operations (i.e. producing input data elements)
Iterator it8 = inputOps.iterator();
while (it8.hasNext()) {
PDMOperation op = (PDMOperation) it8.next();
op.writePDMToDeclare(bw);
}
bw.write("</activitydefinitions>\n");
// write the constraint definition, for now we do not have any
// constraints in the PDM that are translated to Declare
bw.write("<constraintdefinitions>\n");
bw.write("</constraintdefinitions>\n");
// write all dataelements
bw.write("<data>\n");
Iterator it5 = dataElements.values().iterator();
while (it5.hasNext()) {
PDMDataElement dataElement = (PDMDataElement) it5.next();
dataElement.writePDMToDeclare(bw);
}
bw.write("</data>\n");
// write the organizational information
bw.write("<team/>\n");
// TODO: improve graphical positioning of activities. Now they are
// presented in one long line.
// write the graphical positioning information of the Declare model,
// first the initial operation, then the real operations and then the
// input operations.
bw.write("<graphical>\n");
bw.write("<cells>\n");
Iterator it6 = realOps.values().iterator();
Double pos = 10.0;
while (it6.hasNext()) {
PDMOperation operation = (PDMOperation) it6.next();
bw.write(
"<cell activitydefinition=\""
+ operation.getOperationNR()
+ "\" height=\"40.0\" width=\"80.0\" x=\""
+ pos
+ "\" y=\"90.0\" />\n");
pos = pos + 85.0;
}
Iterator it9 = inputOps.iterator();
pos = 10.0;
while (it9.hasNext()) {
PDMOperation operation = (PDMOperation) it9.next();
bw.write(
"<cell activitydefinition=\""
+ operation.getOperationNR()
+ "\" height=\"40.0\" width=\"80.0\" x=\""
+ pos
+ "\" y=\"180.0\" />\n");
pos = pos + 85.0;
}
bw.write("</cells>\n");
// write the connectors
bw.write("<connectors/>\n");
// close the XML file in the right way
bw.write("</graphical>\n");
bw.write("</assignment>\n");
bw.write("</model>\n");
}
public HashSet calculateNextStates(
PDMState state,
PDMStateSpace statespace,
boolean root,
boolean failure,
int numStates,
int breadth) {
HashSet result = new HashSet();
HashSet data = state.dataElements;
HashSet exec1 = state.executedOperations;
HashSet failed = state.failedOperations;
HashSet execOps = calculateExecutableOperations(data, exec1, failed, root);
Iterator it = execOps.iterator();
int b = 0;
int bLimit = 0;
if (!failure) {
bLimit = breadth;
} else {
bLimit = breadth / 2;
}
// for each executable operation a new state is created
while (it.hasNext() && i < numStates && b < bLimit) {
if (!failure) {
PDMOperation op = (PDMOperation) it.next();
PDMDataElement d = op.getOutputElement();
// First, add the state with the operation 'op' succesfully
// executed
HashSet ins2 = (HashSet) data.clone(); // NB: is it necessary to
// clear this clone
// again?
ins2.add(d);
HashSet exec2 = (HashSet) exec1.clone();
exec2.add(op);
PDMState s = checkIfStateExists(statespace, ins2, exec2, failed);
// Check whether the new state already exists
// If so, then another link to this state is made
if (!(s == null)) {
PDMState st = s;
PDMStateEdge edge = new PDMStateEdge(state, st, op.getID(), 1.0);
statespace.addEdge(edge);
}
// If not, a new state is created and linked to the current
// state
else {
String name = "state" + i;
// int num = checkStatusOfState(statespace, )
PDMState st = new PDMState(statespace, name, ins2, exec2, failed);
statespace.addState(st);
result.add(st);
PDMStateEdge edge = new PDMStateEdge(state, st, op.getID(), 1.0);
statespace.addEdge(edge);
i++;
b++;
}
}
// Then, if failure of operations is considered, add the state with
// the failed operations 'op'.
if (failure) {
PDMOperation op = (PDMOperation) it.next();
PDMDataElement d = op.getOutputElement();
// First, add the state with the operation 'op' succesfully
// executed
HashSet ins2 = (HashSet) data.clone(); // NB: is it necessary to
// clear this clone
// again?
ins2.add(d);
HashSet exec2 = (HashSet) exec1.clone();
exec2.add(op);
PDMState s = checkIfStateExists(statespace, ins2, exec2, failed);
// Check whether the new state already exists
// If so, then another link to this state is made
if (!(s == null)) {
PDMState st = s;
double prob = 1.0 - (op.getFailureProbability());
PDMStateEdge edge = new PDMStateEdge(state, st, op.getID(), prob);
statespace.addEdge(edge);
}
// If not, a new state is created and linked to the current
// state
else {
String name = "state" + i;
// int num = checkStatusOfState(statespace, )
PDMState st = new PDMState(statespace, name, ins2, exec2, failed);
statespace.addState(st);
result.add(st);
double prob = 1.0 - (op.getFailureProbability());
PDMStateEdge edge = new PDMStateEdge(state, st, op.getID(), prob);
statespace.addEdge(edge);
i++;
b++;
}
HashSet failed2 = (HashSet) failed.clone();
failed2.add(op);
PDMState s2 = checkIfStateExists(statespace, data, exec1, failed2);
if (!(s2 == null)) {
PDMState st = s2;
PDMStateEdge edge = new PDMStateEdge(state, st, op.getID(), op.getFailureProbability());
statespace.addEdge(edge);
}
// If not, a new state is created and linked to the current
// state
else {
String name = "state" + i;
PDMState st = new PDMState(statespace, name, data, exec1, failed2);
statespace.addState(st);
result.add(st);
PDMStateEdge edge = new PDMStateEdge(state, st, op.getID(), op.getFailureProbability());
statespace.addEdge(edge);
i++;
b++;
}
// failed2.clear();
}
}
return result;
}
public PDMStateSpace calculateSimpleStateSpace(
boolean root, boolean failure, boolean input, boolean colored, int numStates, int breadth) {
PDMStateSpace result = new PDMStateSpace(this, colored);
HashSet states = new HashSet();
int j = (operations.size() + 1);
if (!input) {
HashSet empty = new HashSet();
PDMState st = new PDMState(result, "state" + i, empty, empty, empty);
result.addState(st);
states.add(st);
i++;
} else {
// Start with the complete set of input data elements available
HashSet empty = new HashSet();
String name = new String("state" + i);
HashSet ins = new HashSet(); // this hashSet contains the input
// elements to the process (input
// elements of PDM)
HashSet execOps = new HashSet();
// Fill the hashSet with the leaf elements
HashMap leafs = getLeafElements();
Object[] leafElts = leafs.values().toArray();
for (int i = 0; i < leafElts.length; i++) {
PDMDataElement d = (PDMDataElement) leafElts[i];
ins.add(d);
}
HashSet leafOps = getLeafOperations();
Iterator it = leafOps.iterator();
while (it.hasNext()) {
PDMOperation op = (PDMOperation) it.next();
execOps.add(op);
}
PDMState start = new PDMState(result, name, ins, execOps, empty); // start
// state
// of
// the
// statespace
result.addState(start);
i++;
states.add(start);
}
while (!states.isEmpty()) {
HashSet states2 = (HashSet) states.clone();
Iterator it = states2.iterator();
while (it.hasNext()) {
PDMState state = (PDMState) it.next();
HashSet nextStates = calculateNextStates(state, result, root, failure, numStates, breadth);
Iterator it2 = nextStates.iterator();
// Add the new states to iterator
while (it2.hasNext()) {
PDMState st = (PDMState) it2.next();
states.add(st);
}
states.remove(state);
}
}
i = 0;
j = 0;
Message.add("<PDMMDPStateSpace>", Message.TEST);
Message.add("<NumberOfStates = " + result.getNumberOfStates() + " >", Message.TEST);
Message.add("</PDMMDPStateSpace>", Message.TEST);
return result;
}
public HashSet calculateExecutableOperations(
HashSet dataElts, HashSet executed, HashSet failed, boolean root) {
HashSet result = new HashSet();
HashSet enabledOperations = new HashSet();
if (root) {
// Calculate the enabled operations (i.e. those operation of which
// all input elements are in the set of available elements)
Object[] ops = operations.values().toArray();
for (int i = 0; i < ops.length; i++) {
PDMOperation op = (PDMOperation) ops[i];
HashMap inputs = op.getInputElements();
Object[] ins = inputs.values().toArray();
boolean enabled = true;
int k = 0;
while (enabled && k < ins.length) {
PDMDataElement d = (PDMDataElement) ins[k];
if (!(dataElts.contains(d))) {
enabled = false;
}
k++;
}
if (enabled) {
enabledOperations.add(op);
// System.out.println("Enabled operation: "+ op.getID());
}
}
} else if (!(dataElts.contains(this.getRootElement()))) {
// Calculate the enabled operations (i.e. those operation of which
// all input elements are in the set of available elements)
Object[] ops = operations.values().toArray();
for (int i = 0; i < ops.length; i++) {
PDMOperation op = (PDMOperation) ops[i];
HashMap inputs = op.getInputElements();
Object[] ins = inputs.values().toArray();
boolean enabled = true;
int k = 0;
while (enabled && k < ins.length) {
PDMDataElement d = (PDMDataElement) ins[k];
if (!(dataElts.contains(d))) {
enabled = false;
}
k++;
}
if (enabled) {
enabledOperations.add(op);
}
}
}
// remove already executed operations
Iterator exIt = executed.iterator();
while (exIt.hasNext()) {
PDMOperation op = (PDMOperation) exIt.next();
enabledOperations.remove(op);
}
// remove already failed operations
Iterator fIt = failed.iterator();
while (fIt.hasNext()) {
PDMOperation op = (PDMOperation) fIt.next();
enabledOperations.remove(op);
}
result = enabledOperations;
return result;
}