javax.print.attribute: abstract public class: SetOfIntegerSyntax

javax.print.attribute
abstract public class: SetOfIntegerSyntax [javadoc | source]

java.lang.Object
   javax.print.attribute.SetOfIntegerSyntax

All Implemented Interfaces:
Cloneable, Serializable

Direct Known Subclasses:
PageRanges, CopiesSupported, JobKOctetsSupported, JobImpressionsSupported, JobMediaSheetsSupported, NumberUpSupported

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.

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 (-), or two integers separated by a colon (:). Each integer consists of one or more decimal digits (0 through 9). Whitespace characters cannot appear within an integer but are otherwise ignored. For example: "", "1", "5-10", "1:2, 4".

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 ints; for example, int[0][], int[][]{{1}}, int[][]{{5,10}}, int[][]{{1,2},{4}}.

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.

The SetOfIntegerSyntax object's value is actually stored in "canonical 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 ints in the form {lower bound, upper bound}. An empty set is represented as a zero-length array.

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.

author: David - Mendenhall

author: Alan - Kaminsky

Constructor:

Constructor:
protected SetOfIntegerSyntax(String members) { this.members = parse (members); } Construct a new set-of-integer attribute with the given members in string form. Parameters: `members` - Set members in string form. If null, an empty set is constructed. Throws: `IllegalArgumentException` - (Unchecked exception) Thrown if `members` does not obey the proper syntax. exception: `IllegalArgumentException` - (Unchecked exception) Thrown if `members` does not obey the proper syntax.
protected SetOfIntegerSyntax(int[][] members) { this.members = parse (members); } Construct a new set-of-integer attribute with the given members in array form. Parameters: `members` - Set members in array form. If null, an empty set is constructed. Throws: `NullPointerException` - (Unchecked exception) Thrown if any element of `members` is null. `IllegalArgumentException` - (Unchecked exception) Thrown if any element of `members` is not a length-one or length-two array or if any non-null range in `members` has a lower bound less than zero. exception: `NullPointerException` - (Unchecked exception) Thrown if any element of `members` is null. exception: `IllegalArgumentException` - (Unchecked exception) Thrown if any element of `members` is not a length-one or length-two array or if any non-null range in `members` has a lower bound 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 integer. Parameters: `member` - Set member. Throws: `IllegalArgumentException` - (Unchecked exception) Thrown if `member` is less than zero. exception: `IllegalArgumentException` - (Unchecked exception) Thrown if `member` 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][]; } 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. Parameters: `lowerBound` - Lower bound of the range. `upperBound` - Upper bound of the range. Throws: `IllegalArgumentException` - (Unchecked exception) Thrown if the range is non-null and `lowerBound` is less than zero. exception: `IllegalArgumentException` - (Unchecked exception) Thrown if the range is non-null and `lowerBound` is less than zero.

 protected SetOfIntegerSyntax(String members) {
        this.members = parse (members);
}

Construct a new set-of-integer attribute with the given members in string form.

Parameters:

members - Set members in string form. If null, an empty set is constructed.

Throws:

IllegalArgumentException - (Unchecked exception) Thrown if members does not obey the proper syntax.

exception: IllegalArgumentException - (Unchecked exception) Thrown if members does not obey the proper syntax.

 protected SetOfIntegerSyntax(int[][] members) {
        this.members = parse (members);
}

Construct a new set-of-integer attribute with the given members in array form.

Parameters:

members - Set members in array form. If null, an empty set is constructed.

Throws:

NullPointerException - (Unchecked exception) Thrown if any element of members is null.

IllegalArgumentException - (Unchecked exception) Thrown if any element of members is not a length-one or length-two array or if any non-null range in members has a lower bound less than zero.

exception: NullPointerException - (Unchecked exception) Thrown if any element of members is null.

exception: IllegalArgumentException - (Unchecked exception) Thrown if any element of members is not a length-one or length-two array or if any non-null range in members has a lower bound 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 integer.

Parameters:

member - Set member.

Throws:

IllegalArgumentException - (Unchecked exception) Thrown if member is less than zero.

exception: IllegalArgumentException - (Unchecked exception) Thrown if member 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][];
}

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.

Parameters:

lowerBound - Lower bound of the range.

upperBound - Upper bound of the range.

Throws:

IllegalArgumentException - (Unchecked exception) Thrown if the range is non-null and lowerBound is less than zero.

exception: IllegalArgumentException - (Unchecked exception) Thrown if the range is non-null and lowerBound is less than zero.

Method from javax.print.attribute.SetOfIntegerSyntax Summary:
contains, contains, equals, getMembers, hashCode, next, toString

Methods from java.lang.Object:
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method from javax.print.attribute.SetOfIntegerSyntax Detail:
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 value.
public boolean contains(IntegerSyntax attribute) { return contains (attribute.getValue()); } Determine if this set-of-integer attribute contains the given integer attribute's value.
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 whether this set-of-integer attribute is equivalent to the passed in object. To be equivalent, all of the following conditions must be true: `object` is not null. `object` is an instance of class SetOfIntegerSyntax. This set-of-integer attribute's members and `object`'s members are the same.
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; } 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.
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 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 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; } 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, `-1` is returned. (Since a set-of-integer attribute can only contain nonnegative values, `-1` will never appear in the set.) You can use the `next()` method to iterate through the integer values in a set-of-integer attribute in ascending order, like this: SetOfIntegerSyntax attribute = . . .; int i = -1; while ((i = attribute.next (i)) != -1) { foo (i); }
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(); } 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 `"i"` if the lower bound equals the upper bound or `"i-j"` otherwise.

Method from javax.print.attribute.SetOfIntegerSyntax Detail:

 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 value.

 public boolean contains(IntegerSyntax attribute) {
        return contains (attribute.getValue());
}

Determine if this set-of-integer attribute contains the given integer attribute's value.

 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;
        }
}

object is not null.
object is an instance of class SetOfIntegerSyntax.
This set-of-integer attribute's members and object's members are the same.

 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;
}

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.

 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 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 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;
}

-1

next()

    SetOfIntegerSyntax attribute = . . .;
    int i = -1;
    while ((i = attribute.next (i)) != -1)
        {
        foo (i);
        }

 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();
}

"i"

"i-j"