/*
 * @(#)SetOfIntegerSyntax.java	1.6 04/01/07
 *
 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */


package javax.print.attribute;

import java.io.Serializable;
import java.util.Vector;

/**
 * Class SetOfIntegerSyntax is an abstract base class providing the common 
 * implementation of all attributes whose value is a set of nonnegative 
 * integers. This includes attributes whose value is a single range of integers 
 * and attributes whose value is a set of ranges of integers. 
 * <P>
 * You can construct an instance of SetOfIntegerSyntax by giving it in "string 
 * form." The string consists of zero or more comma-separated integer groups. 
 * Each integer group consists of either one integer, two integers separated by 
 * a hyphen (<CODE>-</CODE>), or two integers separated by a colon 
 * (<CODE>:</CODE>). Each integer consists of one or more decimal digits 
 * (<CODE>0</CODE> through <CODE>9</CODE>). Whitespace characters cannot 
 * appear within an integer but are otherwise ignored. For example: 
 * <CODE>""</CODE>, <CODE>"1"</CODE>, <CODE>"5-10"</CODE>, <CODE>"1:2, 
 * 4"</CODE>. 
 * <P>
 * You can also construct an instance of SetOfIntegerSyntax by giving it in 
 * "array form." Array form consists of an array of zero or more integer groups 
 * where each integer group is a length-1 or length-2 array of 
 * <CODE>int</CODE>s; for example, <CODE>int[0][]</CODE>, 
 * <CODE>int[][]{{1}}</CODE>, <CODE>int[][]{{5,10}}</CODE>, 
 * <CODE>int[][]{{1,2},{4}}</CODE>. 
 * <P>
 * In both string form and array form, each successive integer group gives a 
 * range of integers to be included in the set. The first integer in each group 
 * gives the lower bound of the range; the second integer in each group gives 
 * the upper bound of the range; if there is only one integer in the group, the 
 * upper bound is the same as the lower bound. If the upper bound is less than 
 * the lower bound, it denotes a null range (no values). If the upper bound is 
 * equal to the lower bound, it denotes a range consisting of a single value. If 
 * the upper bound is greater than the lower bound, it denotes a range 
 * consisting of more than one value. The ranges may appear in any order and are 
 * allowed to overlap. The union of all the ranges gives the set's contents. 
 * Once a SetOfIntegerSyntax instance is constructed, its value is immutable. 
 * <P>
 * The SetOfIntegerSyntax object's value is actually stored in "<I>canonical</I> 
 * array form." This is the same as array form, except there are no null ranges; 
 * the members of the set are represented in as few ranges as possible (i.e., 
 * overlapping ranges are coalesced); the ranges appear in ascending order; and 
 * each range is always represented as a length-two array of <CODE>int</CODE>s 
 * in the form {lower bound, upper bound}. An empty set is represented as a 
 * zero-length array. 
 * <P> 
 * Class SetOfIntegerSyntax has operations to return the set's members in 
 * canonical array form, to test whether a given integer is a member of the 
 * set, and to iterate through the members of the set.
 * <P>
 *
 * @author  David Mendenhall
 * @author  Alan Kaminsky
 */
public abstract class SetOfIntegerSyntax implements Serializable, Cloneable {

    private static final long serialVersionUID = 3666874174847632203L;

    /**
     * This set's members in canonical array form.
     * @serial
     */
    private int[][] members;


    /**
     * Construct a new set-of-integer attribute with the given members in
     * string form. 
     *
     * @param  members  Set members in string form. If null, an empty set is
     *                     constructed.
     *
     * @exception  IllegalArgumentException
     *     (Unchecked exception) Thrown if <CODE>members</CODE> does not 
     *    obey  the proper syntax. 
     */
    protected SetOfIntegerSyntax(String members) {
	this.members = parse (members);
    }

    /**
     * Parse the given string, returning canonical array form.
     */
    private static int[][] parse(String members) {
	// Create vector to hold int[] elements, each element being one range 
	// parsed out of members. 
	Vector theRanges = new Vector();
	
	// Run state machine over members.
	int n = (members == null ? 0 : members.length());
	int i = 0;
	int state = 0;
	int lb = 0;
	int ub = 0;
	char c;
	int digit;
	while (i < n) {
	    c = members.charAt(i ++);
	    switch (state) {

	    case 0: // Before first integer in first group
		if (Character.isWhitespace(c)) {
		    state = 0;
		}
		else if ((digit = Character.digit(c, 10)) != -1) {
		    lb = digit;
		    state = 1;
		} else {
		    throw new IllegalArgumentException();
		}
		break;
		
	    case 1: // In first integer in a group
		if (Character.isWhitespace(c)){
			state = 2;
		} else if ((digit = Character.digit(c, 10)) != -1) {
		    lb = 10 * lb + digit;
		    state = 1;
		} else if (c == '-' || c == ':') {
		    state = 3;
		} else if (c == ',') {
		    accumulate (theRanges, lb, lb);
		    state = 6;
		} else {
		    throw new IllegalArgumentException();
		}
		break;

	    case 2: // After first integer in a group
		if (Character.isWhitespace(c)) {
		    state = 2;
		} 
		else if (c == '-' || c == ':') {
		    state = 3;
		}
		else if (c == ',') {
		    accumulate(theRanges, lb, lb);
		    state = 6;
		} else {
		    throw new IllegalArgumentException();
		}
		break;

	    case 3: // Before second integer in a group
		if (Character.isWhitespace(c)) {
		    state = 3;
		} else if ((digit = Character.digit(c, 10)) != -1) {
		    ub = digit;
		    state = 4;
		} else {
		    throw new IllegalArgumentException();
		}
		break;

	    case 4: // In second integer in a group
		if (Character.isWhitespace(c)) {
		    state = 5;
		} else if ((digit = Character.digit(c, 10)) != -1) {
		    ub = 10 * ub + digit;
		    state = 4;
		} else if (c == ',') {
		    accumulate(theRanges, lb, ub);
		    state = 6;
		} else {
		    throw new IllegalArgumentException();
		}
		break;
		
	    case 5: // After second integer in a group
		if (Character.isWhitespace(c)) {
		    state = 5;
		} else if (c == ',') {
		    accumulate(theRanges, lb, ub);
		    state = 6;
		} else {
		    throw new IllegalArgumentException();
		}
		break;

	    case 6: // Before first integer in second or later group
		if (Character.isWhitespace(c)) {
		    state = 6;
		} else if ((digit = Character.digit(c, 10)) != -1) {
		    lb = digit;
		    state = 1;
		} else {
		    throw new IllegalArgumentException();
		}
		break;
	    }
	}

	// Finish off the state machine.
	switch (state) {
	case 0: // Before first integer in first group
	    break;
	case 1: // In first integer in a group
	case 2: // After first integer in a group
	    accumulate(theRanges, lb, lb);
	    break;
	case 4: // In second integer in a group
	case 5: // After second integer in a group
	    accumulate(theRanges, lb, ub);
	    break;
	case 3: // Before second integer in a group
	case 6: // Before first integer in second or later group
	    throw new IllegalArgumentException();
	}

	// Return canonical array form.
	return canonicalArrayForm (theRanges);
    }

    /**
     * Accumulate the given range (lb .. ub) into the canonical array form 
     * into the given vector of int[] objects. 
     */
    private static void accumulate(Vector ranges, int lb,int ub) {
	// Make sure range is non-null.
	if (lb <= ub) {
	    // Stick range at the back of the vector.
	    ranges.add(new int[] {lb, ub});

	    // Work towards the front of the vector to integrate the new range 
	    // with the existing ranges. 
	    for (int j = ranges.size()-2; j >= 0; -- j) {
	    // Get lower and upper bounds of the two ranges being compared.
		int[] rangea = (int[]) ranges.elementAt (j);
		int lba = rangea[0];
		int uba = rangea[1];
		int[] rangeb = (int[]) ranges.elementAt (j+1);
		int lbb = rangeb[0];
		int ubb = rangeb[1];

		/* If the two ranges overlap or are adjacent, coalesce them. 
		 * The two ranges overlap if the larger lower bound is less 
		 * than or equal to the smaller upper bound. The two ranges 
		 * are adjacent if the larger lower bound is one greater
		 * than the smaller upper bound. 
		 */
		if (Math.max(lba, lbb) - Math.min(uba, ubb) <= 1) {
		    // The coalesced range is from the smaller lower bound to 
		    // the larger upper bound.
		    ranges.setElementAt(new int[]
					   {Math.min(lba, lbb),
						Math.max(uba, ubb)}, j);
		    ranges.remove (j+1);
		} else if (lba > lbb) {

		    /* If the two ranges don't overlap and aren't adjacent but 
		     * are out of order, swap them. 
		     */
		    ranges.setElementAt (rangeb, j);
		    ranges.setElementAt (rangea, j+1);
		} else {
		/* If the two ranges don't overlap and aren't adjacent and 
		 * aren't out of order, we're done early. 
		 */
		    break;
		}
	    }
	}
    }

    /**
     * Convert the given vector of int[] objects to canonical array form.
     */
    private static int[][] canonicalArrayForm(Vector ranges) {
	return (int[][]) ranges.toArray (new int[ranges.size()][]);
    }

    /**
     * Construct a new set-of-integer attribute with the given members in 
     * array form. 
     *
     * @param  members  Set members in array form. If null, an empty set is
     *                     constructed.
     *
     * @exception  NullPointerException
     *     (Unchecked exception) Thrown if any element of 
     *     <CODE>members</CODE> is null. 
     * @exception  IllegalArgumentException
     *     (Unchecked exception) Thrown if any element of 
     *     <CODE>members</CODE> is not a length-one or length-two array or if 
     *     any non-null range in <CODE>members</CODE> has a lower bound less 
     *     than zero. 
     */
    protected SetOfIntegerSyntax(int[][] members) {
	this.members = parse (members);
    }

    /**
     * Parse the given array form, returning canonical array form.
     */
    private static int[][] parse(int[][] members) {
	// Create vector to hold int[] elements, each element being one range 
	// parsed out of members. 
	Vector ranges = new Vector();

	// Process all integer groups in members.
	int n = (members == null ? 0 : members.length);
	for (int i = 0; i < n; ++ i) {
	    // Get lower and upper bounds of the range.
	    int lb, ub;
	    if (members[i].length == 1) {
		lb = ub = members[i][0];
	    } else if (members[i].length == 2) {
		lb = members[i][0];
		ub = members[i][1];
	    } else {
		throw new IllegalArgumentException();
	    }

	    // Verify valid bounds.
	    if (lb <= ub && lb < 0) {
		throw new IllegalArgumentException();
	    }

	    // Accumulate the range.
	    accumulate(ranges, lb, ub);
	}

		// Return canonical array form.
		return canonicalArrayForm (ranges);
		}

    /**
     * Construct a new set-of-integer attribute containing a single integer.
     *
     * @param  member  Set member.
     *
     * @exception  IllegalArgumentException
     *     (Unchecked exception) Thrown if <CODE>member</CODE> is less than 
     *     zero. 
     */
    protected SetOfIntegerSyntax(int member) {
	if (member < 0) {
	    throw new IllegalArgumentException();
	}
	members = new int[][] {{member, member}};
    }

    /**
     * Construct a new set-of-integer attribute containing a single range of 
     * integers. If the lower bound is greater than the upper bound (a null 
     * range), an empty set is constructed. 
     *
     * @param  lowerBound  Lower bound of the range.
     * @param  upperBound  Upper bound of the range.
     *
     * @exception  IllegalArgumentException
     *     (Unchecked exception) Thrown if the range is non-null and 
     *     <CODE>lowerBound</CODE> is less than zero. 
     */
    protected SetOfIntegerSyntax(int lowerBound, int upperBound) {
	if (lowerBound <= upperBound && lowerBound < 0) {
	    throw new IllegalArgumentException();
	}
	members = lowerBound <=upperBound ?
	    new int[][] {{lowerBound, upperBound}} :
	    new int[0][];
    }


    /**
     * Obtain this set-of-integer attribute's members in canonical array form.
     * The returned array is "safe;" the client may alter it without affecting
     * this set-of-integer attribute.
     *
     * @return  This set-of-integer attribute's members in canonical array form.
     */
    public int[][] getMembers() {
	int n = members.length;
	int[][] result = new int[n][];
	for (int i = 0; i < n; ++ i) {
	    result[i] = new int[] {members[i][0], members[i][1]};
	}
	return result;
    }
    
    /**
     * Determine if this set-of-integer attribute contains the given value.
     *
     * @param  x  Integer value.
     *
     * @return  True if this set-of-integer attribute contains the value
     *          <CODE>x</CODE>, false otherwise.
     */
    public boolean contains(int x) {
	// Do a linear search to find the range that contains x, if any. 
	int n = members.length;
	for (int i = 0; i < n; ++ i) {
	    if (x < members[i][0]) {
		return false;
	    } else if (x <= members[i][1]) {
		return true;
	    }
	}
	return false;
    }

    /**
     * Determine if this set-of-integer attribute contains the given integer 
     * attribute's value. 
     *
     * @param  attribute  Integer attribute.
     *
     * @return  True if this set-of-integer attribute contains
     *          <CODE>theAttribute</CODE>'s value, false otherwise. 
     */
    public boolean contains(IntegerSyntax attribute) {
	return contains (attribute.getValue());
    }

    /**
     * Determine the smallest integer in this set-of-integer attribute that is 
     * greater than the given value. If there are no integers in this 
     * set-of-integer attribute greater than the given value, <CODE>-1</CODE> is 
     * returned. (Since a set-of-integer attribute can only contain nonnegative 
     * values, <CODE>-1</CODE> will never appear in the set.) You can use the 
     * <CODE>next()</CODE> method to iterate through the integer values in a 
     * set-of-integer attribute in ascending order, like this: 
     * <PRE>
     *     SetOfIntegerSyntax attribute = . . .;
     *     int i = -1;
     *     while ((i = attribute.next (i)) != -1)
     *         {
     *         foo (i);
     *         }
     * </PRE>
     *
     * @param  x  Integer value.
     *
     * @return  The smallest integer in this set-of-integer attribute that is 
     *          greater than <CODE>x</CODE>, or <CODE>-1</CODE> if no integer in 
     *          this set-of-integer attribute is greater than <CODE>x</CODE>. 
     */
    public int next(int x) {
	// Do a linear search to find the range that contains x, if any. 
	int n = members.length;
	for (int i = 0; i < n; ++ i) {
	    if (x < members[i][0]) {
		return members[i][0];
	    } else if (x < members[i][1]) {
		return x + 1;
	    }
	}
	return -1;
    }
    
    /**
     * Returns whether this set-of-integer attribute is equivalent to the passed 
     * in object. To be equivalent, all of the following conditions must be 
     * true: 
     * <OL TYPE=1>
     * <LI>
     * <CODE>object</CODE> is not null.
     * <LI>
     * <CODE>object</CODE> is an instance of class SetOfIntegerSyntax.
     * <LI>
     * This set-of-integer attribute's members and <CODE>object</CODE>'s 
     * members are the same. 
     * </OL>
     *
     * @param  object  Object to compare to.
     *
     * @return  True if <CODE>object</CODE> is equivalent to this
     *          set-of-integer attribute, false otherwise. 
     */
    public boolean equals(Object object) {
	if (object != null && object instanceof SetOfIntegerSyntax) {
	    int[][] myMembers = this.members;
	    int[][] otherMembers = ((SetOfIntegerSyntax) object).members;
	    int m = myMembers.length;
	    int n = otherMembers.length;
	    if (m == n) { 
		for (int i = 0; i < m; ++ i) {
		    if (myMembers[i][0] != otherMembers[i][0] ||
			myMembers[i][1] != otherMembers[i][1]) {
			return false;
		    }
		}
		return true;
	    } else {
		return false;
	    }
	} else {
	    return false;
	}
    }

    /**
     * Returns a hash code value for this set-of-integer attribute. The hash 
     * code is the sum of the lower and upper bounds of the ranges in the 
     * canonical array form, or 0 for an empty set.
     */
    public int hashCode() {
	int result = 0;
	int n = members.length;
	for (int i = 0; i < n; ++ i) {
	    result += members[i][0] + members[i][1];
	}
	return result;
    }

    /**
     * Returns a string value corresponding to this set-of-integer attribute. 
     * The string value is a zero-length string if this set is empty. Otherwise, 
     * the string value is a comma-separated list of the ranges in the canonical 
     * array form, where each range is represented as <CODE>"<I>i</I>"</CODE> if 
     * the lower bound equals the upper bound or 
     * <CODE>"<I>i</I>-<I>j</I>"</CODE> otherwise. 
     */
    public String toString() {
	StringBuffer result = new StringBuffer();
	int n = members.length;
	for (int i = 0; i < n; i++) {
	    if (i > 0) {
		result.append (',');
	    }
	    result.append (members[i][0]);
	    if (members[i][0] != members[i][1]) {
		result.append ('-');
		result.append (members[i][1]);
	    }
	}
	return result.toString();
    }
    
}
