private void initStack(XNContext parent) {
initStack();
firstResponder = parent.firstResponder;
responderStack.addAll(parent.responderStack);
callStack.addAll(parent.callStack);
result = parent.result;
}
public GenomeLocSortedSet subtractRegions(GenomeLocSortedSet toRemoveSet) {
LinkedList<GenomeLoc> good = new LinkedList<GenomeLoc>();
Stack<GenomeLoc> toProcess = new Stack<GenomeLoc>();
Stack<GenomeLoc> toExclude = new Stack<GenomeLoc>();
// initialize the stacks
toProcess.addAll(mArray);
Collections.reverse(toProcess);
toExclude.addAll(toRemoveSet.mArray);
Collections.reverse(toExclude);
int i = 0;
while (!toProcess.empty()) { // while there's still stuff to process
if (toExclude.empty()) {
good.addAll(toProcess); // no more excludes, all the processing stuff is good
break;
}
GenomeLoc p = toProcess.peek();
GenomeLoc e = toExclude.peek();
if (p.overlapsP(e)) {
toProcess.pop();
for (GenomeLoc newP : p.subtract(e)) toProcess.push(newP);
} else if (p.compareContigs(e) < 0) {
good.add(toProcess.pop()); // p is now good
} else if (p.compareContigs(e) > 0) {
toExclude.pop(); // e can't effect anything
} else if (p.getStop() < e.getStart()) {
good.add(toProcess.pop()); // p stops before e starts, p is good
} else if (e.getStop() < p.getStart()) {
toExclude.pop(); // p starts after e stops, e is done
} else {
throw new ReviewedStingException("BUG: unexpected condition: p=" + p + ", e=" + e);
}
if (i++ % 10000 == 0) logger.debug("removeRegions operation: i = " + i);
}
return createSetFromList(genomeLocParser, good);
}
private void generateMoveForPosition(int color, int position) {
Stack<Integer> flipStack = new Stack<Integer>(); // list of all flips found for position
int pointer; // pointer to position that is currently being evaluated
// loop through each possible line radiating from position
for (int i = 0; i < ADJACENT_ADDERS.length; i++) {
Stack<Integer> lineStack = new Stack<Integer>(); // list of flips found on individual radial
pointer = position + ADJACENT_ADDERS[i];
boolean foundSameColor = false;
// loop through each position in the line
// end loop if same color, edge, or empty space found
boolean loop = true;
while (loop) {
int stateAtPointer = this.positions[pointer];
switch (stateAtPointer) {
case 0:
loop = false;
break; // found empty
case -2:
loop = false;
break; // found edge
default:
int colorEvaluate = color * stateAtPointer;
switch (colorEvaluate) {
case 1: // found same color
foundSameColor = true;
loop = false;
break;
case -1: // found opposite color
lineStack.push(pointer);
pointer += ADJACENT_ADDERS[i];
break;
}
break;
}
}
if (foundSameColor && lineStack.size() > 0) {
flipStack.addAll(
lineStack); // join lineStack with flipStack if flips found along current radial
}
}
// push the move on to legalMovesList if valid flips found. otherwise do nothing.
switch (flipStack.size()) {
case 0:
break; // do nothing
default:
this.legalMovesList.push(new Move(position, flipStack));
break;
}
}
/**
* Merge list of expressions into a tree of logical/relational expressions. This is done
* recursively in several passes, one per level of precedence starting at the highest precedence
* level. Recursion exits when a single expression remains.
*
* @param listExpressions list of expressions to merge
* @param precedenceLevel the precedence level that is to be merged
* @return tree of expressions with a single root expression
*/
private List<Expression> mergeExpressions(List<Expression> listExpressions, int precedenceLevel) {
if (listExpressions.size() > 1) {
Stack<Expression> stack = new Stack<Expression>();
stack.push(listExpressions.remove(0));
while (!listExpressions.isEmpty()) {
Expression exp = stack.pop();
Expression left = stack.empty() ? null : stack.pop();
Expression right = listExpressions.remove(0);
stack.addAll(exp.merge(left, right, precedenceLevel));
}
return mergeExpressions(new ArrayList<Expression>(stack), precedenceLevel - 1);
}
return listExpressions;
}
