// Walks the tree, checking to make sure that we haven't violated any // logical constraints. This is a method for debugging. public boolean check() { String path = pathLabel(); if (suffixLink != null) { String suffixPath = suffixLink.pathLabel(); if (!path.substring(1, path.length()).equals(suffixPath)) { logger.log( Level.SEVERE, String.format("Suffix Link for node (%s) didn't match: %s", path, suffixPath)); return false; } } for (char c : childEdges.keySet()) { TreeEdge e = childEdges.get(c); if (!e.check()) { return false; } } for (int k : terminalEdges.keySet()) { TreeEdge e = terminalEdges.get(k); if (!e.check()) { return false; } } return true; }
public void finishFinalEdges() { for (TreeEdge edge : edgesWithE) { if (edge.isEndSymbolic()) { edge.setEnd(lastE); } } edgesWithE.clear(); }
public String pathLabel() { if (parentEdge != null) { StringBuilder sb = new StringBuilder(parentEdge.headNode.pathLabel()); for (int i = 0; i < parentEdge.length(); i++) { sb.append(parentEdge.getChar(i)); } return sb.toString(); } else { return ""; } }
public void addEdge(TreeEdge e) { if (e.start() == e.string.length() - 1) { int key = e.string.getIndex(); if (terminalEdges.containsKey(key)) { throw new IllegalArgumentException(); } e.headNode = this; terminalEdges.put(key, e); } else { char key = e.getChar(0); if (childEdges.containsKey(key)) { throw new IllegalArgumentException(); } e.headNode = this; childEdges.put(key, e); } }
public void print(int indent, PrintStream ps) { if (isLeaf()) { printSuffixes(ps); ps.println(); } else { int i = 0; for (char c : childEdges.keySet()) { TreeEdge edge = childEdges.get(c); edge.print(indent, i != 0, ps); i++; } for (int k : terminalEdges.keySet()) { TreeEdge edge = terminalEdges.get(k); edge.print(indent, i != 0, ps); i++; } } }
public void matchFrom(TreeNode startNode, boolean skipcount) { assert string != null || array != null; assert lastEdge == null; matchingFrom = start; matchedTo = start; // a base case. if (end - start <= 0) { return; } char nextChar = getChar(matchingFrom); assert startNode != null; System.err.println("startNode is " + startNode + " and nextChar is " + nextChar); if (startNode.childEdges.containsKey(nextChar)) { lastEdge = startNode.childEdges.get(nextChar); } else if (skipcount) { System.err.println("Failure Node: "); startNode.print(0, System.err); System.err.println(); System.err.flush(); throw new IllegalArgumentException(); } boolean keepMatching = lastEdge != null; while (keepMatching) { int remaining = end - matchingFrom; int matching = skipcount ? Math.min(lastEdge.length(), remaining) : (string != null ? lastEdge.countMatches(string, matchingFrom, end) : lastEdge.countMatches(array, matchingFrom, end)); matchedTo = matchingFrom + matching; if (matching < lastEdge.length()) { // we either matched all the way into the middle of the // current edge, or we found a mismatch in the current edge. // either way, update the matchedTo variable and we're done. keepMatching = false; } else { if (matching < remaining) { nextChar = getChar(matchedTo); if (lastEdge.tailNode.childEdges.containsKey(nextChar)) { lastEdge = lastEdge.tailNode.childEdges.get(nextChar); matchingFrom += matching; } else if (skipcount) { System.err.println("ERROR TREE: "); print(System.err); System.err.println(); System.err.flush(); String err = String.format( "[%s] node:'%s' (next: %c)", toString(), startNode.pathLabel(), nextChar); throw new IllegalArgumentException(err); } else { keepMatching = false; } } else { keepMatching = false; } } } }
public boolean inEdgeMiddle() { return lastEdge != null && lastMatchLength() < lastEdge.length(); }