/** * Determines and retrieves data related to the first confluence node (defined as a node with two * or more incoming transitions) of a _transition path corresponding to a given String from a * given node. * * @param originNode the MDAGNode from which the _transition path corresponding to str starts from * @param str a String corresponding to a _transition path in the MDAG * @return a HashMap of Strings to Objects containing: - an int denoting the length of the path to * the first confluence node in the _transition path of interest - the MDAGNode which is the * first confluence node in the _transition path of interest (or null if one does not exist) */ private HashMap<String, Object> getTransitionPathFirstConfluenceNodeData( MDAGNode originNode, String str) { int currentIndex = 0; int charCount = str.length(); MDAGNode currentNode = originNode; // Loop thorugh the characters in str, sequentially using them to _transition through the MDAG // in search of // (and breaking upon reaching) the first node that is the target of two or more transitions. // The loop is // also broken from if the currently processing node doesn't have a _transition labeled with the // currently processing char. for (; currentIndex < charCount; currentIndex++) { char currentChar = str.charAt(currentIndex); currentNode = (currentNode.hasOutgoingTransition(currentChar) ? currentNode.transition(currentChar) : null); if (currentNode == null || currentNode.isConfluenceNode()) break; } ///// boolean noConfluenceNode = (currentNode == originNode || currentIndex == charCount); // Create a HashMap containing the index of the last char in the substring corresponding // to the transitoin path to the confluence node, as well as the actual confluence node HashMap<String, Object> confluenceNodeDataHashMap = new HashMap<String, Object>(2); confluenceNodeDataHashMap.put( "toConfluenceNodeTransitionCharIndex", (noConfluenceNode ? null : currentIndex)); confluenceNodeDataHashMap.put("confluenceNode", noConfluenceNode ? null : currentNode); ///// return confluenceNodeDataHashMap; }
/** * Determines the longest prefix of a given String that is the prefix of another String previously * added to the MDAG. * * @param str the String to be processed * @return a String of the longest prefix of {@code str} that is also a prefix of a String * contained in the MDAG */ private String determineLongestPrefixInMDAG(String str) { MDAGNode currentNode = sourceNode; int numberOfChars = str.length(); int onePastPrefixEndIndex = 0; // Loop through the characters in str, using them in sequence to _transition // through the MDAG until the currently processing node doesn't have a _transition // labeled with the current processing char, or there are no more characters to process. for (int i = 0; i < numberOfChars; i++, onePastPrefixEndIndex++) { char currentChar = str.charAt(i); if (currentNode.hasOutgoingTransition(currentChar)) currentNode = currentNode.transition(currentChar); else break; } ///// return str.substring(0, onePastPrefixEndIndex); }