SetOfIntegerSyntax is the abstract base class of all attribute
* classes which provide a set of non-negative integers as value (e.g. the
* page ranges to print) represented as single values or ranges of values.
*
* A SetOfIntegerSyntax instance consists of an integer array of
* ranges. Ranges may have the same lower and upper bound representing a single
* integer value. Ranges with a lower bound greater than the upper bound are
* null ranges and discarded. Ranges may overlap in their values. In no case
* negative integers are allowed.
*
* There are several constructors available: *
SetOfIntegerSyntax(int member)SetOfIntegerSyntax(int lowerBound, int upperBound)SetOfIntegerSyntax(int[][] members)int[0][] for empty set of integers, int[][] {{1}}
* , int[][] {{1,5}}, int[][] {{1,5},{7,9}},
* int[][] {{3,7},{19}}.
* SetOfIntegerSyntax(String s)"" for an empty set of integers,
* "1", "1-5", "1-5,7-9",
* "3-7,19" and "1:2,4".
*
* Internal storage:
* The set of integers are stored internally in a normalized array form.
* In the normalized array form the set of integer ranges are represented
* in as few ranges as possible and overlapping ranges are merged. The ranges
* are always represented as an integer array of length two with ranges
* stored in {lower bound, upper bound} form. The ranges are stored in
* ascending order, without any null ranges.
*
SetOfIntegerSyntax object.
*
* @param member the member value
*
* @exception IllegalArgumentException if member is < 0
*/
protected SetOfIntegerSyntax(int member)
{
if (member < 0)
throw new IllegalArgumentException("member may not be less than 0");
this.members = new int[][]{{member, member}};
}
/**
* Creates a SetOfIntegerSyntax object.
*
* @param members the members to use in this set. If
* null an empty set is created.
*
* @exception IllegalArgumentException if any element is invalid
* @exception NullPointerException if any element of members is null
*/
protected SetOfIntegerSyntax(int[][] members)
{
int[][] newMembers;
int outIndex = 0;
if (members == null)
newMembers = new int[0][];
else
{
newMembers = new int[members.length][];
for (int index = 0; index < members.length; index++)
{
int lower;
int upper;
if (members[index].length == 1)
{
lower = members[index][0];
upper = members[index][0];
}
else if (members[index].length == 2)
{
lower = members[index][0];
upper = members[index][1];
}
else
throw new IllegalArgumentException("invalid member element");
// We only want to reject non-null ranges where lower<0.
if (lower <= upper && lower < 0)
throw new IllegalArgumentException("invalid member element");
if (lower <= upper)
{
int[] range = new int[2];
range[0] = lower;
range[1] = upper;
newMembers[outIndex++] = range;
}
}
}
this.members = normalize(newMembers, outIndex);
}
private boolean skipWhitespace(StringCharacterIterator i)
{
while (Character.isWhitespace(i.current()))
i.next();
return i.current() == CharacterIterator.DONE;
}
private boolean skipNumber(StringCharacterIterator i)
{
boolean readAny = false;
while (Character.isDigit(i.current()))
{
readAny = true;
i.next();
}
return readAny;
}
/**
* Creates a SetOfIntegerSyntax object.
*
* @param s the members to use in this set in string form. If
* null an empty set is created.
*
* @exception IllegalArgumentException if any element is invalid
*/
protected SetOfIntegerSyntax(String s)
{
if (s == null)
this.members = normalize(new int[0][], 0);
else
{
ArrayList vals = new ArrayList();
StringCharacterIterator it = new StringCharacterIterator(s);
while (true)
{
// Skip whitespace.
if (skipWhitespace(it))
break;
// Parse integer.
int index = it.getIndex();
if (! skipNumber(it))
throw new IllegalArgumentException();
int[] item = new int[2];
item[0] = Integer.parseInt(s.substring(index, it.getIndex()));
if (! skipWhitespace(it))
{
char c = it.current();
if (c == ':' || c == '-')
{
it.next();
if (skipWhitespace(it))
throw new IllegalArgumentException();
index = it.getIndex();
if (! skipNumber(it))
throw new IllegalArgumentException();
item[1] = Integer.parseInt(s.substring(index, it.getIndex()));
}
else
item[1] = item[0];
}
else
item[1] = item[0];
if (item[0] <= item[1])
vals.add(item);
if (skipWhitespace(it))
break;
if (it.current() != ',')
throw new IllegalArgumentException();
it.next();
}
members = normalize((int[][]) vals.toArray(new int[0][]), vals.size());
}
}
/**
* Creates a SetOfIntegerSyntax object.
*
* @param lowerBound the lower bound value
* @param upperBound the upper bound value
*
* @exception IllegalArgumentException if lowerBound <= upperbound
* and lowerBound < 0
*/
protected SetOfIntegerSyntax(int lowerBound, int upperBound)
{
// We only want to reject non-null ranges where lower<0.
if (lowerBound <= upperBound
&& lowerBound < 0)
throw new IllegalArgumentException();
members = (lowerBound <= upperBound ? new int[][]{{lowerBound, upperBound}}
: new int[0][]);
}
/**
* Checks if this set contains the given value.
*
* @param value the value to test for
*
* @return true if this set contains value, false otherwise
*/
public boolean contains(int value)
{
// This only works on a normalized member array.
for (int index = 0; index < members.length; index++)
{
if (value < members[index][0])
return false;
else if (value <= members[index][1])
return true;
}
return false;
}
/**
* Checks if this set contains the given value.
*
* @param value the value to test for
*
* @return true if this set contains value, false otherwise
*/
public boolean contains(IntegerSyntax value)
{
return contains(value.getValue());
}
/**
* Tests if the given object is equal to this object.
*
* @param obj the object to test
*
* @return true if both objects are equal, false otherwise.
*/
public boolean equals(Object obj)
{
if (! (obj instanceof SetOfIntegerSyntax))
return false;
SetOfIntegerSyntax other = (SetOfIntegerSyntax) obj;
if (other.members.length != members.length)
return false;
for (int i = 0; i < members.length; ++i)
{
if (members[i][0] != other.members[i][0]
|| members[i][1] != other.members[i][1])
return false;
}
return true;
}
/**
* Returns an array describing the members included in this set.
*
* @return The members in normalized array form.
*/
public int[][] getMembers()
{
return (int[][]) members.clone();
}
/**
* Returns the hashcode for this object.
*
* @return The hashcode.
*/
public int hashCode()
{
int result = 0;
for (int i = 0; i < members.length; ++i)
result += members[i][0] + members[i][1];
return result;
}
/**
* Returns the smallest value that is greater than x which is in this set.
*
* @param x an integer value
*
* @return The next smallest integer value, or -1 if there
* is no greater integer in the set.
*/
public int next(int x)
{
for (int i = 0; i < members.length; ++i)
{
if (x >= members[i][1])
continue;
if (x < members[i][0])
return members[i][0];
// X is in this range.
return x + 1;
}
return -1;
}
/**
* Returns the string representation for this object.
* The value is a zero length string for an empty set, or a comma seperated
* list of ranges and single values in the form "1-2,5-7,10".
*
* @return The string representation.
*/
public String toString()
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < members.length; ++i)
{
if (i > 0)
sb.append(',');
sb.append(members[i][0]);
if (members[i][0] != members[i][1])
{
sb.append('-');
sb.append(members[i][1]);
}
}
return sb.toString();
}
}