import java.util.*;

/**
 *  Create all possible word combinations from a given set of characters.
 *  Note: using more than 6 characters creates too many options at this time.
 *  The options are easily calculated, but may not fit in an output TextArea.
 *  (6 characters creates 720 combinations; 7 characters creates 5,040
 *  combinations.)
 *
 *  @version 1.0
 *  @author Developer's Daily (http://www.devdaily.com)
 */
public class ThreadedJumbleCalc extends Thread {

	int numChars;
	char[] chars;
	char[] currCharArray;
	int[]  currIndex;
	
    /**
     *  Set the array of possible characters for this calculation.
     *  @param char[] an array of possible characters (defined by the user)
     */
	public void setPossibleChars (char[] possibleChars) {
	    numChars = possibleChars.length;
	    
	    chars           = new char[numChars];
		currCharArray   = new char[numChars];
		currIndex       = new int[numChars];
	    
	    for (int i=0; i<numChars; i++) {
	        chars[i] = possibleChars[i];
	    }
	}
	
	
    /**
     *  Call this class with an empty vector to perform the calculations.
     *  @param vectorOfStrings The Vector that will contain the list of possible
     *     Strings calculated by this method. An empty vector should be passed in,
     *     and the calculated results will populate the vector.
     */
	public void runCalcs (Vector vectorOfStrings) {
	    
	    runCalcs (0, vectorOfStrings);      // this sets the "vectorOfStrings" elements
	    vectorOfStrings.trimToSize();
	}
	
	
    /**
     *  Performs the calculations by recursively calling itself.
     *
     *  @param depth The current recursion depth.
     *  @param vectorOfStrings The list of possible Strings calculated by this method.
     */
	private void runCalcs (int depth, Vector vectorOfStrings) {

        //  if depth==numChars, add the StringBuffer to the Vector
        
	    if (depth == numChars) {

	        StringBuffer sb = new StringBuffer(numChars);
	        sb.append(currCharArray);
	        vectorOfStrings.addElement(sb.toString());

	    } else {

	        // come here if recursion depth < numChars
	        
	        boolean goDeeper;
	        for (int j=0; j<numChars; j++) {
	            goDeeper = true;
	            currIndex[depth] = j;
	            for (int k=0; k<depth; k++) {
	                if (currIndex[depth] == currIndex[k]) {
	                    goDeeper = false;
	                    break;
	                }
	            }

                // here's the recursive call to runCalcs()
	            if (goDeeper) {
	                currCharArray[depth] = chars[j];
	                runCalcs(depth+1, vectorOfStrings);
	            }
	        }
	    }
	        
	} // end runCalcs

}