java.lang.Object
- com.jidesoft.range.AbstractRange<T>
- - com.jidesoft.range.CategoryRange<T>

All Implemented Interfaces:

Range<T>, java.lang.Comparable<Range>, java.lang.Iterable<Category<T>>
```
public class CategoryRange<T>
extends AbstractRange<T>
implements java.lang.Iterable<Category<T>>
```
Note that this class is iterable so you can use it in an advanced for.. loop

Author:

Simon White (swhite@catalysoft.com)

Field Summary

Fields
Modifier and Type Field Description

static java.lang.String PROPERTY_COMPARATOR

static java.lang.String PROPERTY_SORTED

static java.lang.String PROPERTY_VALUES
- Fields inherited from interface com.jidesoft.range.Range
  PROPERTY_MAX, PROPERTY_MIN

Constructor Summary

Constructors
Constructor	Description
`CategoryRange()`
`CategoryRange(CategoryRange<T> categoryRange)`	Create a new CategoryRange by copying an existing one.
`CategoryRange(java.util.Set<T> values)`	Create a CategoryRange from a set of values.
`CategoryRange(T... values)`	Create a CategoryRange from the supplied values

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`CategoryRange<T>`	`add(Category<T> c)`	Adds a category to the range.
`void`	`adjust(T lower, T upper)`	Not supported for Category Ranges
`boolean`	`contains(Category<T> value)`	Determines whether the category range contains the specified category value
`boolean`	`contains(T x)`	Determines whether the category range contains the supplied possible value
`Range<T>`	`copy()`
`Range<T>`	`createIntermediate(Range<T> target, double position)`	Creates an intermediate range between this range and a target range.
`boolean`	`equals(java.lang.Object obj)`
`Category<T>`	`getCategory(int position)`	Returns the category with the supplied position value.
`java.util.List<Category<T>>`	`getCategoryValues()`	Returns a list of the category values in this range
`java.util.Comparator<T>`	`getComparator()`	Returns the comparator that, if set, will be used to sort the values in the range
`java.util.List<T>`	`getPossibleValues()`
`int`	`hashCode()`
`boolean`	`isSorted()`	Returns a value to indicate whether the categories of the range are sorted
`java.util.Iterator<Category<T>>`	`iterator()`	Returns an iterator for the category values
`T`	`lower()`
`double`	`maximum()`	This may be the numeric representation of upper() or it may be rounded up.
`double`	`minimum()`	This may be the numeric representation of lower() or it may be rounded down.
`int`	`position(T value)`
`void`	`reset()`	Reset the maximum and minimum.
`void`	`setComparator(java.util.Comparator<T> comparator)`	Specify the comparator that will be used to sort the values in the range.
`void`	`setMaximum(double value)`
`void`	`setMinimum(double value)`
`void`	`setSorted(boolean sorted)`	Specify whether the categories of the range should be sorted.
`double`	`size()`	Returns the size of the range, as given by the maximum minus the minimum.
`java.lang.String`	`toString()`
`T`	`upper()`

Methods inherited from class com.jidesoft.range.AbstractRange
addPropertyChangeListener, compareTo, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, getPropertyChangeListeners, getPropertyChangeListeners, removePropertyChangeListener

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - PROPERTY_VALUES
```
public static final java.lang.String PROPERTY_VALUES
```
    See Also:
    
    Constant Field Values
  - PROPERTY_COMPARATOR
```
public static final java.lang.String PROPERTY_COMPARATOR
```
    See Also:
    
    Constant Field Values
  - PROPERTY_SORTED
```
public static final java.lang.String PROPERTY_SORTED
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - CategoryRange
```
public CategoryRange()
```
  - CategoryRange
```
public CategoryRange(T... values)
```
    Create a CategoryRange from the supplied values
    
    Parameters:
    
    values - the values.
  - CategoryRange
```
public CategoryRange(java.util.Set<T> values)
```
    Create a CategoryRange from a set of values. Note that internally, a list is created out of the set so that the class can reliably determine an upper() and a lower() value.
    
    Parameters:
    
    values - - the set of possible values
  - CategoryRange
```
public CategoryRange(CategoryRange<T> categoryRange)
```
    Create a new CategoryRange by copying an existing one. This would allow you subsequently to tweak the values in the copy without affecting the original.
    
    Parameters:
    
    categoryRange - the category range instance to copy
- Method Detail
  - getPossibleValues
```
public java.util.List<T> getPossibleValues()
```
  - getCategory
```
public Category<T> getCategory(int position)
```
    Returns the category with the supplied position value. (Note that the first position is 1, not 0.)
    
    Parameters:
    
    position - the position of a category along an axis
    
    Returns:
    
    the category with the supplied position value.
  - add
```
public CategoryRange<T> add(Category<T> c)
```
    Adds a category to the range. Note that after adding categories, you will need to call reset() if you want the minimum and maximum numeric values of the range to be recomputed.
    
    This method fires a property change event, but to avoid cloning a list for efficiency, the old value is always null
    
    Parameters:
    
    c - the category to add
    
    Returns:
    
    this range
  - setSorted
```
public void setSorted(boolean sorted)
```
    Specify whether the categories of the range should be sorted. If you call this method with true but do not explicitly set a comparator for the sort ordering, then the natural ordering of the objects (using java.util.Comparable) will be used. If the objects do not implement Comparable, then a string comparator is constructed based on the toString() method of the object.
    
    Parameters:
    
    sorted - whether the categories of the range should be sorted
  - isSorted
```
public boolean isSorted()
```
    Returns a value to indicate whether the categories of the range are sorted
    
    Returns:
    
    a value to indicate whether the categories of the range are sorted
  - getComparator
```
public java.util.Comparator<T> getComparator()
```
    Returns the comparator that, if set, will be used to sort the values in the range
    
    Returns:
    
    the comparator that, if set, will be used to sort the values in the range
  - setComparator
```
public void setComparator(java.util.Comparator<T> comparator)
```
    Specify the comparator that will be used to sort the values in the range. Calling this method implicitly calls setSorted(): the sorted property will be set to true if the comparator is non-null and will be set to false if the comparator is null
    
    Parameters:
    
    comparator - the comparator to be used to sort the values in the range
  - copy
```
public Range<T> copy()
```
    Overrides:
    
    copy in class AbstractRange<T>
  - lower
```
public T lower()
```
    Specified by:
    
    lower in interface Range<T>
    
    Returns:
    
    the smallest value of the range
  - upper
```
public T upper()
```
    Specified by:
    
    upper in interface Range<T>
    
    Returns:
    
    the largest value of the range
  - adjust
```
public void adjust(T lower,
                   T upper)
```
    Not supported for Category Ranges
    
    Specified by:
    
    adjust in interface Range<T>
    
    Parameters:
    
    lower - the new smallest value of the range
    
    upper - the new largest value of the range
  - maximum
```
public double maximum()
```
    Description copied from interface: Range
    
    This may be the numeric representation of upper() or it may be rounded up.
    
    Specified by:
    
    maximum in interface Range<T>
    
    Returns:
    
    the maximum value for the axis in the range
    
    See Also:
    
    Range.maximum()
  - minimum
```
public double minimum()
```
    Description copied from interface: Range
    
    This may be the numeric representation of lower() or it may be rounded down.
    
    Specified by:
    
    minimum in interface Range<T>
    
    Returns:
    
    the minimum value for the axis in the range
    
    See Also:
    
    Range.minimum()
  - reset
```
public void reset()
```
    Reset the maximum and minimum. They will be recomputed on the next call to minimum() or maximum() respectively
  - setMinimum
```
public void setMinimum(double value)
```
  - setMaximum
```
public void setMaximum(double value)
```
  - size
```
public double size()
```
    Returns the size of the range, as given by the maximum minus the minimum. To compute the size of the range in terms of the number of members in the category, use getPossibleValue().size()
    
    Specified by:
    
    size in interface Range<T>
    
    Returns:
    
    the size of the range
    
    See Also:
    
    Range.size()
  - position
```
public int position(T value)
```
  - contains
```
public boolean contains(T x)
```
    Determines whether the category range contains the supplied possible value
    
    Specified by:
    
    contains in interface Range<T>
    
    Returns:
    
    a boolean to indicate whether the supplied point lies within the range
  - contains
```
public boolean contains(Category<T> value)
```
    Determines whether the category range contains the specified category value
    
    Parameters:
    
    value - the category value.
    
    Returns:
    
    true if the range contains the specified value. Otherwise false.
  - iterator
```
public java.util.Iterator<Category<T>> iterator()
```
    Returns an iterator for the category values
    
    Specified by:
    
    iterator in interface java.lang.Iterable<T>
    
    Returns:
    
    an iterator for the category values
  - getCategoryValues
```
public java.util.List<Category<T>> getCategoryValues()
```
    Returns a list of the category values in this range
    
    Returns:
    
    a list of category values
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - createIntermediate
```
public Range<T> createIntermediate(Range<T> target,
                                   double position)
```
    Creates an intermediate range between this range and a target range. Used for range morphing.
    
    Specified by:
    
    createIntermediate in class AbstractRange<T>
    
    Parameters:
    
    target - the target range of the morph
    
    position - a value between 0 and 1 indicating the position of the morph
    
    Returns:
    
    a CategoryRange
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Modifier and Type	Field	Description
`static java.lang.String`	`PROPERTY_COMPARATOR`
`static java.lang.String`	`PROPERTY_SORTED`
`static java.lang.String`	`PROPERTY_VALUES`

Class CategoryRange<T>

Field Summary

Fields inherited from interface com.jidesoft.range.Range

Constructor Summary

Method Summary

Methods inherited from class com.jidesoft.range.AbstractRange

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Field Detail

PROPERTY_VALUES

PROPERTY_COMPARATOR

PROPERTY_SORTED

Constructor Detail

CategoryRange

CategoryRange

CategoryRange

CategoryRange

Method Detail

getPossibleValues

getCategory

add

setSorted

isSorted

getComparator

setComparator

copy

lower

upper

adjust

maximum

minimum

reset

setMinimum

setMaximum

size

position

contains

contains

iterator

getCategoryValues

hashCode

equals

createIntermediate

toString