/**
* Backtracking function that finds the location of the queens and back tracks if an acceptable
* solution cannot be found
*
* @param startx x coordinate of the starting location
* @param starty y coordinate of the starting location
* @return
*/
public boolean backTrack(int startx, int starty) {
int j = startx;
for (int i = starty; i < gridLength; ) {
for (; j < gridLength; j++) {
if (!killList.contains(i + "," + j)) {
grid[i][j] = addToKillList(i, j);
myStack.push(i + "," + j);
continue;
}
}
/*
* Here we check if there are i queens in i rows, else we backtrack to the
* previous decision point by assigning the values to i,j
* Else we continue
*/
if (myStack.size() > 0 && (i + 1) != myStack.size()) {
String[] temp = myStack.pop().split(",");
int x = Integer.parseInt(temp[0]);
int y = Integer.parseInt(temp[1]);
removeFromKillList(x, y);
grid[x][y] = 0;
i = x;
j = y + 1;
} else {
i++;
j = 0;
}
}
if (numberofSpaces() == gridLength) return true;
return false;
}
/**
* Record the current state of the tree walk which includes the current node and stack state as
* well as the lookahead buffer.
*/
public int mark() {
if (markers == null) {
markers = new ArrayList();
markers.add(null); // depth 0 means no backtracking, leave blank
}
markDepth++;
TreeWalkState state = null;
if (markDepth >= markers.size()) {
state = new TreeWalkState();
markers.add(state);
} else {
state = (TreeWalkState) markers.get(markDepth);
}
state.absoluteNodeIndex = absoluteNodeIndex;
state.currentChildIndex = currentChildIndex;
state.currentNode = currentNode;
state.previousNode = previousNode;
state.nodeStackSize = nodeStack.size();
state.indexStackSize = indexStack.size();
// take snapshot of lookahead buffer
int n = getLookaheadSize();
int i = 0;
state.lookahead = new Object[n];
for (int k = 1; k <= n; k++, i++) {
state.lookahead[i] = LT(k);
}
lastMarker = markDepth;
return markDepth;
}
private void checkForCollisionsWithTowers(Ring ring) {
Stack stack = null;
Sprite tower = null;
if (ring.collidesWith(mTower1)
&& (mStack1.size() == 0 || ring.getmWeight() < ((Ring) mStack1.peek()).getmWeight())) {
stack = mStack1;
tower = mTower1;
} else if (ring.collidesWith(mTower2)
&& (mStack2.size() == 0 || ring.getmWeight() < ((Ring) mStack2.peek()).getmWeight())) {
stack = mStack2;
tower = mTower2;
} else if (ring.collidesWith(mTower3)
&& (mStack3.size() == 0 || ring.getmWeight() < ((Ring) mStack3.peek()).getmWeight())) {
stack = mStack3;
tower = mTower3;
} else {
stack = ring.getmStack();
tower = ring.getmTower();
}
ring.getmStack().remove(ring);
if (stack != null && tower != null && stack.size() == 0) {
ring.setPosition(
tower.getX() + tower.getWidth() / 2 - ring.getWidth() / 2,
tower.getY() + tower.getHeight() - ring.getHeight());
} else if (stack != null && tower != null && stack.size() > 0) {
ring.setPosition(
tower.getX() + tower.getWidth() / 2 - ring.getWidth() / 2,
((Ring) stack.peek()).getY() - ring.getHeight());
}
stack.add(ring);
ring.setmStack(stack);
ring.setmTower(tower);
}
public static String reverseWord(String words) {
if (words == null || words.equalsIgnoreCase("")) return "";
else {
char[] chs = words.toCharArray();
// System.out.println(new String(chs));
Stack stack = new Stack();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < chs.length; i++) {
if (isChar(chs[i])) {
stack.push(chs[i]);
} else {
while (stack.size() > 0) {
sb.append(stack.pop());
}
sb.append(chs[i]);
}
}
if (stack.size() > 0) {
while (stack.size() > 0) {
sb.append(stack.pop());
}
}
return sb.toString();
}
}
public int longestValidParentheses(String s) {
Stack<String> paren = new Stack<String>();
Stack<Integer> indexes = new Stack<Integer>();
for (int i = 0; i < s.length(); i++) {
if (paren.isEmpty()) {
paren.push(String.valueOf((s.charAt(i))));
indexes.push(i);
} else if (s.charAt(i) == ')' && paren.peek().equals("(")) {
paren.pop();
indexes.pop();
} else {
paren.push(String.valueOf((s.charAt(i))));
indexes.push(i);
}
}
int rmax = 0;
if (indexes.size() == 0) return s.length();
for (int i = 0; i < indexes.size(); i++) {
if (i == 0) {
if (indexes.get(i) > rmax) rmax = indexes.get(i);
} else {
if (indexes.get(i) - indexes.get(i - 1) > rmax) rmax = indexes.get(i) - indexes.get(i - 1);
}
if (i == indexes.size() - 1) {
if (s.length() - 1 - indexes.get(i) > rmax) rmax = s.length() - 1 - indexes.get(i);
}
}
// System.out.println(indexes.size());
return (rmax > 1) ? rmax : 0;
}
private void getIndentFromState(
List<IndentCommand> iis, boolean updateState, int lineStartOffset) {
Stack<TplStackItem> blockStack = getStack();
int lastUnprocessedItem = blockStack.size();
for (int i = blockStack.size() - 1; i >= 0; i--) {
if (!blockStack.get(i).processed) {
lastUnprocessedItem = i;
} else {
break;
}
}
for (int i = lastUnprocessedItem; i < blockStack.size(); i++) {
TplStackItem item = blockStack.get(i);
assert !item.processed : item;
if (item.state == StackItemState.IN_BODY) {
IndentCommand ii = new IndentCommand(IndentCommand.Type.INDENT, lineStartOffset);
if (item.indent != -1) {
ii.setFixedIndentSize(item.indent);
}
iis.add(ii);
if (updateState) {
item.processed = Boolean.TRUE;
}
} else if (item.state == StackItemState.BODY_FINISHED) {
IndentCommand ii = new IndentCommand(IndentCommand.Type.RETURN, lineStartOffset);
iis.add(ii);
if (updateState) {
item.processed = Boolean.TRUE;
blockStack.remove(i);
i--;
}
}
}
}
/**
* "Normalize" the given absolute path.
*
* <p>This includes:
*
* <ul>
* <li>Uppercase the drive letter if there is one.
* <li>Remove redundant slashes after the drive spec.
* <li>Resolve all ./, .\, ../ and ..\ sequences.
* <li>DOS style paths that start with a drive letter will have \ as the separator.
* </ul>
*
* Unlike {@link File#getCanonicalPath()} this method specifically does not resolve symbolic
* links.
*
* @param path the path to be normalized.
* @return the normalized version of the path.
* @throws java.lang.NullPointerException if path is null.
*/
public static File normalize(final String path) {
Stack s = new Stack();
String[] dissect = dissect(path);
s.push(dissect[0]);
StringTokenizer tok = new StringTokenizer(dissect[1], File.separator);
while (tok.hasMoreTokens()) {
String thisToken = tok.nextToken();
if (".".equals(thisToken)) {
continue;
}
if ("..".equals(thisToken)) {
if (s.size() < 2) {
// Cannot resolve it, so skip it.
return new File(path);
}
s.pop();
} else { // plain component
s.push(thisToken);
}
}
StringBuffer sb = new StringBuffer();
for (int i = 0; i < s.size(); i++) {
if (i > 1) {
// not before the filesystem root and not after it, since root
// already contains one
sb.append(File.separatorChar);
}
sb.append(s.elementAt(i));
}
return new File(sb.toString());
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.back:
prevId.pop();
prevPath.pop();
String present_path = prevPath.elementAt(prevPath.size() - 1);
if (present_path.equalsIgnoreCase("HOME")) back.setEnabled(false);
else back.setEnabled(true);
int present_id = prevId.elementAt(prevId.size() - 1);
Log.i("id", "" + present_id);
Log.i("path", present_path);
ArrayList<SearchResults> Results = getData(String.valueOf(present_id));
adapt = new MyCustomBaseAdapter(SkydriveFolderList.this, Results);
lv.setAdapter(adapt);
adapt.notifyDataSetChanged();
path.setText(present_path);
break;
case R.id.search:
// getResult(et.getText().toString());
break;
}
// TODO Auto-generated method stub
}
/** @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.FunctionExpression) */
public Object visit(Function expression, Object notUsed) {
if (!fcs.supports(expression.getClass())) {
postStack.push(expression);
return null;
}
if (expression.getName() == null) {
postStack.push(expression);
return null;
}
int i = postStack.size();
int j = preStack.size();
for (int k = 0; k < expression.getParameters().size(); k++) {
((Expression) expression.getParameters().get(i)).accept(this, null);
if (i < postStack.size()) {
while (j < preStack.size()) preStack.pop();
postStack.pop();
postStack.push(expression);
return null;
}
}
while (j < preStack.size()) preStack.pop();
preStack.push(expression);
return null;
}
public static void reset(boolean useMoreBuildings, boolean useEvenMoreBuildings) {
GeneralSupply.useMoreBuildings = useMoreBuildings;
GeneralSupply.useEvenMoreBuildings = useEvenMoreBuildings;
stallsLeft.clear();
stallsLeft.addAll(Arrays.asList(STALLS));
if (!useEvenMoreBuildings) {
stallsLeft.remove(stallsLeft.size() - 1);
}
if (!useMoreBuildings) {
stallsLeft.remove(stallsLeft.size() - 1);
}
if (Main.DEBUG) {
stallsLeft.clear();
stallsLeft.add(STALLS[0]);
stallsLeft.add(STALLS[1]);
}
Collections.shuffle(stallsLeft);
troughsLeft = MAX_TROUGHS;
extsLeft.clear();
extsLeft.addAll(Arrays.asList(EXTS));
if (!useEvenMoreBuildings) {
extsLeft.remove(extsLeft.size() - 1);
}
if (!useMoreBuildings) {
extsLeft.remove(extsLeft.size() - 1);
}
Collections.shuffle(extsLeft);
extsUsed.clear();
SPECIAL_BUILDINGS.clear(); // clear building instances
randomizeBuildings(INITIAL_BUILDING_COUNTS);
}
private int recursive(
Transaction txn,
final String endProt,
Stack<String> path,
int bestDepth,
final int maxDepth) {
DatabaseEntry key = new DatabaseEntry();
DatabaseEntry data = new DatabaseEntry();
StringBinding.stringToEntry(path.lastElement(), key);
if (this.database.get(txn, key, data, null) == OperationStatus.SUCCESS) {
Set<String> partners = this.bindingSet.entryToObject(data);
for (String prot2 : partners) {
int depth = -1;
if (prot2.equals(endProt)) {
depth = path.size() - 1;
} else if (path.size() < maxDepth && !path.contains(prot2)) {
path.push(prot2);
depth = recursive(txn, endProt, path, bestDepth, maxDepth);
path.pop();
}
if (depth != -1 && (bestDepth == -1 || bestDepth > depth)) {
bestDepth = depth;
}
}
}
return bestDepth;
}
public ListNode FindFirstCommonNode_01(ListNode pHead1, ListNode pHead2) {
if (pHead1 == null || pHead2 == null) {
return null;
}
Stack<ListNode> p1 = new Stack<ListNode>();
Stack<ListNode> p2 = new Stack<ListNode>();
ListNode h1 = pHead1;
ListNode h2 = pHead2;
while (h1 != null || h2 != null) { // 入栈操作O(n)
if (h1 != null) {
p1.push(h1);
h1 = h1.next;
}
if (h2 != null) {
p2.push(h2);
h2 = h2.next;
}
}
ListNode pre = null;
while (p1.size() != 0 && p2.size() != 0) { // 寻找相同节点O(m)
ListNode t1 = p1.pop();
ListNode t2 = p2.pop();
if (t1 == t2) {
pre = t1;
} else {
break;
}
}
return pre;
}
public static double postFixEvaluate(String input) {
String input1 = infixToPostfix(input);
System.out.println("Post fix expression: " + input1);
Stack<Double> comp = new Stack<Double>(); // computation stack.
Scanner scan = new Scanner(input1 + " $");
while (true) {
if (scan.hasNextDouble()) {
comp.push(scan.nextDouble());
} else if (scan.hasNext(opPattern)) {
char op = scan.next().charAt(0);
if (op == '$') {
break;
}
if (comp.size() < 2) {
throw new RuntimeException("invalid expression evaluation");
}
double b = comp.pop();
double a = comp.pop();
comp.push(eval(op, a, b));
}
}
if (comp.size() == 1) return comp.pop();
else throw new RuntimeException("invalid expression evaluation");
}
protected void handleTagEnd(
List<BBCodeItem> bbCodeItems, Stack<String> tags, BBCodeToken bbCodeToken) {
int size = 0;
if (bbCodeToken != null) {
String endTag = bbCodeToken.getEndTag();
for (size = tags.size() - 1; size >= 0; size--) {
if (endTag.equals(tags.elementAt(size))) {
break;
}
}
}
if (size >= 0) {
for (int i = tags.size() - 1; i >= size; i--) {
BBCodeItem bbCodeItem = new BBCodeItem(TYPE_TAG_END, null, tags.elementAt(i));
bbCodeItems.add(bbCodeItem);
}
tags.setSize(size);
}
}
public static boolean match(String filename, String wildcardMatcher) {
if (filename == null && wildcardMatcher == null) {
return true;
}
if (filename == null || wildcardMatcher == null) {
return false;
}
filename = convertCase(filename.replace('\\', '/'));
wildcardMatcher = convertCase(wildcardMatcher.replace('\\', '/'));
String[] wcs = splitOnTokens(wildcardMatcher);
boolean anyChars = false;
int textIdx = 0;
int wcsIdx = 0;
Stack<int[]> backtrack = new Stack<int[]>();
do {
if (backtrack.size() > 0) {
int[] array = backtrack.pop();
wcsIdx = array[0];
textIdx = array[1];
anyChars = true;
}
while (wcsIdx < wcs.length) {
if (wcs[wcsIdx].equals("?")) {
textIdx++;
anyChars = false;
} else if (wcs[wcsIdx].equals("*")) {
anyChars = true;
if (wcsIdx == wcs.length - 1) {
textIdx = filename.length();
}
} else {
if (anyChars) {
textIdx = filename.indexOf(wcs[wcsIdx], textIdx);
if (textIdx == -1) {
break;
}
int repeat = filename.indexOf(wcs[wcsIdx], textIdx + 1);
if (repeat >= 0) {
backtrack.push(new int[] {wcsIdx, repeat});
}
} else {
if (!filename.startsWith(wcs[wcsIdx], textIdx)) {
break;
}
}
textIdx += wcs[wcsIdx].length();
anyChars = false;
}
wcsIdx++;
}
if (wcsIdx == wcs.length && textIdx == filename.length()) {
return true;
}
} while (backtrack.size() > 0);
return false;
}
@Override
public Object process(
Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
throws SemanticException {
JoinTypeCheckCtx ctx = (JoinTypeCheckCtx) procCtx;
if (ctx.getError() != null) {
return null;
}
ASTNode expr = (ASTNode) nd;
ASTNode parent = stack.size() > 1 ? (ASTNode) stack.get(stack.size() - 2) : null;
if (expr.getType() != HiveParser.TOK_TABLE_OR_COL) {
ctx.setError(ErrorMsg.INVALID_COLUMN.getMsg(expr), expr);
return null;
}
assert (expr.getChildCount() == 1);
String tableOrCol = BaseSemanticAnalyzer.unescapeIdentifier(expr.getChild(0).getText());
boolean qualifiedAccess = (parent != null && parent.getType() == HiveParser.DOT);
ColumnInfo colInfo = null;
if (!qualifiedAccess) {
colInfo = getColInfo(ctx, null, tableOrCol, expr);
// It's a column.
return new ExprNodeColumnDesc(colInfo);
} else if (hasTableAlias(ctx, tableOrCol, expr)) {
return null;
} else {
// Qualified column access for which table was not found
throw new SemanticException(ErrorMsg.INVALID_TABLE_ALIAS.getMsg(expr));
}
}
public List<Interval> merge(List<Interval> intervals) {
if (intervals == null) return null;
Collections.sort(intervals, new IntervalComparator());
Stack<Interval> stack = new Stack<Interval>();
for (Interval i : intervals) {
if (stack.isEmpty()) {
stack.push(i);
} else {
Interval t = stack.peek();
if (hasOverlap(t, i)) {
Interval newInterval = new Interval(t.start, Math.max(t.end, i.end));
stack.pop();
stack.push(newInterval);
} else {
stack.push(i);
}
}
}
int length = stack.size() - 1;
Interval[] intervalArray = new Interval[stack.size()];
for (int i = length; i >= 0; i--) {
intervalArray[i] = stack.pop();
}
return Arrays.asList(intervalArray);
}
/**
* Build an array of the folios that constitute this Manuscript
*
* @return array of folios in correct order
* @throws SQLException
*/
public Folio[] getFolios() throws SQLException {
Connection j = null;
PreparedStatement stmt = null;
try {
j = DatabaseWrapper.getConnection();
String qry = "select * from folios where msID=? order by sequence,pageNumber ";
if (this.getArchive().compareTo("Stanford") == 0)
qry = "select * from folios where msID=? order by sequence";
stmt = j.prepareStatement(qry);
stmt.setInt(1, id);
ResultSet rs = stmt.executeQuery();
Stack<String> pageNames = new Stack();
Stack<Integer> pageNumbers = new Stack();
while (rs.next()) {
// toret+="<option
// value=\""+rs.getInt("pageNumber")+"\">"+textdisplay.archive.getShelfMark(rs.getString("archive"))+" "+rs.getString("collection")+" "+rs.getString("pageName")+"</option>";
// pageNames.add(rs.getString("pageName"));
pageNames.add(
Folio.zeroPadLastNumberFourPlaces(rs.getString("pageName").replace("-000", "")));
pageNumbers.add(rs.getInt("pageNumber"));
}
int[] pageNumbersArray = new int[pageNumbers.size()];
String[] paddedPageNameArray = new String[pageNames.size()];
for (int i = 0; i < paddedPageNameArray.length; i++) {
paddedPageNameArray[i] = pageNames.elementAt(i);
pageNumbersArray[i] = pageNumbers.get(i);
}
if (this.getArchive().compareTo("Stanford") != 0) {
// sort the pages according to the zero padded names of the pages
for (int i = 0; i < paddedPageNameArray.length; i++) {
for (int k = 0; k < paddedPageNameArray.length - 1; k++) {
if (paddedPageNameArray[k].compareTo(paddedPageNameArray[k + 1]) > 0) {
String tmpStr = paddedPageNameArray[k];
paddedPageNameArray[k] = paddedPageNameArray[k + 1];
paddedPageNameArray[k + 1] = tmpStr;
int tmpInt = pageNumbersArray[k];
pageNumbersArray[k] = pageNumbersArray[k + 1];
pageNumbersArray[k + 1] = tmpInt;
}
}
}
}
Folio[] toret = new Folio[pageNumbersArray.length];
for (int i = 0; i < toret.length; i++) {
toret[i] = new Folio(pageNumbersArray[i]);
}
return toret;
} finally {
DatabaseWrapper.closeDBConnection(j);
DatabaseWrapper.closePreparedStatement(stmt);
}
}
public int pop() {
if (stack1.size() == 1 && stack2.size() == 0) {
return stack1.pop();
} else if (stack2.size() == 0) {
popToOtherStack(stack1, stack2);
}
return stack2.pop();
}
/**
* This method attempts to solve the RPN equation given as a string
*
* @param calculation - String containing the RPN formatted string.
* @return An Integer object containing the result, or null if something is wrong.
*/
public Integer doCalculation(String calculation) {
String[] calculationSplit = calculation.split(" ");
for (String str : calculationSplit) {
log.debug(str);
if (str.matches("\\d.*")) {
// Number, push it onto the stack.
numbersStack.push(new Integer(str));
} else if (str.length() == 1) {
if (numbersStack.size() >= 2) {
Integer n3 = null;
Integer n2 = numbersStack.pop();
Integer n1 = numbersStack.pop();
switch (str.charAt(0)) {
case '-':
n3 = n1 - n2;
break;
case '+':
n3 = n1 + n2;
break;
case '*':
n3 = n1 * n2;
break;
case '/':
if (n2 == 0) return null;
n3 = n1 / n2;
break;
// For some reason we got an operator that there is no logic for
default:
return null;
}
if (n3 != null) {
numbersStack.push(n3);
}
} else { // There aren't enough numbers to operate on, this means the RPN equation is
// illegal/incorrect
return null;
}
} else {
return null;
}
}
// Check to see how many numbers are left in the stack...
if (numbersStack.size() > 1) {
return null;
} else {
int returnResult = numbersStack.pop();
log.info("Returning result: " + returnResult);
return new Integer(returnResult);
}
}
public void restoreVertex() {
if (this.vertexStore == null || this.vertexStore.size() == 0)
throw new RuntimeException("Nothing to restore");
int prevVertex = this.vertexStore.pop();
if (prevVertex > edgeStack.size())
throw new RuntimeException("Cannot restore vertex from backtrack");
while (prevVertex < edgeStack.size()) {
popVertex();
}
}
/**
* Gets the geometry parsed by this handler. This method should only be called AFTER the parser
* has completed execution
*
* @return the parsed Geometry, or a GeometryCollection if more than one geometry was parsed
* @throws IllegalStateException if called before the parse is complete
*/
public Geometry getGeometry() {
if (stack.size() == 1) {
Handler h = (Handler) stack.peek();
if (h.children.size() == 1) return (Geometry) h.children.get(0);
return gf.createGeometryCollection(
(Geometry[]) h.children.toArray(new Geometry[stack.size()]));
}
throw new IllegalStateException(
"Parse did not complete as expected, there are " + stack.size() + " elements on the Stack");
}
public void addBufferLine() {
checkState(itemStack.size() > 0);
if (itemStack.size() > 1) {
StackItem child = itemStack.pop();
StackItem parent = itemStack.pop();
buffer.append(StringUtils.join(parent.getId(), " -> ", child.getId(), ";\n"));
itemStack.push(parent);
itemStack.push(child);
}
}
public void saveState(Bundle outState) {
outState.putInt("cmdStack.size", mCommandStack.size());
for (int i = 0; i < mCommandStack.size(); i++) {
AbstractCommand command = mCommandStack.get(i);
Bundle commandState = new Bundle();
commandState.putString("commandClass", command.getCommandClass());
command.saveState(commandState);
outState.putBundle("cmdStack." + i, commandState);
}
}
public int[][] getArrayOfStates() { // gets array of states in sequence to reach the final state
int temp;
int[][] statesSequence = new int[stack.size()][numberOfStates];
for (int i = stack.size() - 1; i >= 0; i--) {
temp = (int) stack.pop();
for (int j = 0; j < numberOfStates; j++) {
statesSequence[i][j] = states.get(temp)[j];
}
}
return statesSequence;
}
/**
* Create new instance from top two elements of stack.
*
* @param stack stack
* @return new instance
*/
public static Rule getRule(final Stack<Object> stack) {
if (stack.size() < 2) {
throw new IllegalArgumentException(
"Invalid EQUALS rule - expected two parameters but received " + stack.size());
}
String p2 = stack.pop().toString();
String p1 = stack.pop().toString();
return getRule(p1, p2);
}
/**
* Compare the content of the current path and the specified path to decide weather they are equal
* or not.
*
* @param p A path to compare to the curent one.
* @return True if both paths are equal.
*/
public boolean equals(Path p) {
if (nodePath.size() != p.nodePath.size()) {
return false;
} else {
for (int i = 0; i < nodePath.size(); i++) {
if (nodePath.get(i) != p.nodePath.get(i)) {
return false;
}
}
}
return true;
}
public void doWait() {
if (pStack.size() == 0) return;
Debug.println("trace", "Waiting for process " + pStack.size());
try {
pStack.peek().waitFor();
// wait for process to complete (does not work as expected for Windows programs)
Debug.println("trace", "Process " + pStack.size() + " is done");
} catch (Exception ex) {
JOptionPane.showMessageDialog(this, "Error" + ex, "Error", JOptionPane.ERROR_MESSAGE);
}
pStack.pop();
}
// update doc tree according to open stack emlement
void updateDoc() {
Node root = (Node) doc;
Stack<Node> shadow = new Stack<Node>();
// get html Element
Node rightMost = null;
for (int i = 0; i < root.childNodesAsArray().length; i++) {
if (root.childNode(i).nodeName().endsWith("html")) {
rightMost = root.childNode(i);
break;
}
}
shadow.push(rightMost);
// get body Element, considering body1
while (rightMost.childNodesAsArray().length > 0) {
rightMost = rightMost.childNodesAsArray()[rightMost.childNodesAsArray().length - 1];
shadow.push(rightMost);
}
shadow.push(rightMost);
// pop out the elements those are supposed to be complete
while (shadow.size() > stack.size()) shadow.pop();
while (shadow.size() > 0) {
Node current = shadow.pop();
// System.out.println("stack.peekLast().nodeName(): "+stack.peekLast().nodeName());
// System.out.println("current.nodeName() : "+current.nodeName());
if (stack.peekLast().nodeName().equals("body")
|| stack.peekLast().nodeName().equals("head")
|| current.nodeName().equals("body")
|| current.nodeName().equals("head")) break;
if (current.nodeName().equals(stack.peekLast().nodeName())) {
stack.pollLast();
((Element) current).onlyStartTag = true;
} else {
System.out.println(
Thread.currentThread().getName() + " err: stack doesn't match with shadow stack");
}
}
// FileWriter file = null;
// try {
// file = new FileWriter(Thread.currentThread().getName()+"doc.html");
// } catch (IOException e) {
// e.printStackTrace();
// }
// PrintWriter out = new PrintWriter(file);
// out.println(doc);
// out.close();
}
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;
}
}
