src/jsr166x/NavigableSet.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

package jsr166x;
import java.util.*;

/**
 * A {@link SortedSet} extended with navigation methods reporting
 * closest matches for given search targets. Methods {@code lower},
 * {@code floor}, {@code ceiling}, and {@code higher} return keys
 * respectively less than, less than or equal, greater than or equal,
 * and greater than a given key, returning {@code null} if there is
 * no such key.  A {@code NavigableSet} may be viewed and traversed
 * in either ascending or descending order.  The {@code Collection}
 * {@code iterator} method returns an ascending {@code Iterator} and
 * the additional method {@code descendingIterator} returns
 * descending iterator. The performance of ascending traversals is
 * likely to be faster than descending traversals.  This interface
 * additionally defines methods {@code pollFirst} and
 * <t>pollLast</tt> that return and remove the lowest and highest key,
 * if one exists, else returning {@code null}.
 *
 * <p>The return values of navigation methods may be ambiguous in
 * implementations that permit {@code null} elements. However, even
 * in this case the result can be disambiguated by checking
 * {@code contains(null)}. To avoid such issues, implementations of
 * this interface are encouraged <em>not</em> to permit insertion of
 * {@code null} elements. (Note that sorted sets of {@link
 * Comparable} elements intrinsically do not permit {@code null}.)
 *
 * @author Doug Lea
 * @param <E> the type of elements maintained by this set
 */
public interface NavigableSet<E> extends SortedSet<E> {
    /**
     * Returns an element greater than or equal to the given element, or
     * {@code null} if there is no such element.
     *
     * @param o the value to match
     * @return an element greater than or equal to given element, or
     * {@code null} if there is no such element.
     * @throws ClassCastException if o cannot be compared with the elements
     *            currently in the set.
     * @throws NullPointerException if o is {@code null}
     * and this set deas not permit {@code null} elements
     */
    public E ceiling(E o);

    /**
     * Returns an element strictly less than the given element, or
     * {@code null} if there is no such element.
     *
     * @param o the value to match
     * @return the greatest element less than the given element, or
     * {@code null} if there is no such element.
     * @throws ClassCastException if o cannot be compared with the elements
     *            currently in the set
     * @throws NullPointerException if o is {@code null}
     * and this set deas not permit {@code null} elements
     */
    public E lower(E o);

    /**
     * Returns an element less than or equal to the given element, or
     * {@code null} if there is no such element.
     *
     * @param o the value to match
     * @return the greatest element less than or equal to given
     * element, or {@code null} if there is no such element
     * @throws ClassCastException if o cannot be compared with the elements
     *            currently in the set
     * @throws NullPointerException if o is {@code null}
     * and this set deas not permit {@code null} elements
     */
    public E floor(E o);

    /**
     * Returns an element strictly greater than the given element, or
     * {@code null} if there is no such element.
     *
     * @param o the value to match
     * @return the least element greater than the given element, or
     * {@code null} if there is no such element.
     * @throws ClassCastException if o cannot be compared with the elements
     *            currently in the set
     * @throws NullPointerException if o is {@code null}
     * and this set deas not permit {@code null} elements
     */
    public E higher(E o);

    /**
     * Retrieves and removes the first (lowest) element.
     *
     * @return the first element, or {@code null} if empty
     */
    public E pollFirst();

    /**
     * Retrieves and removes the last (highest) element.
     *
     * @return the last element, or {@code null} if empty
     */
    public E pollLast();

    /**
     * Returns an iterator over the elements in this collection, in
     * descending order.
     *
     * @return an {@code Iterator} over the elements in this collection
     */
    Iterator<E> descendingIterator();

    /**
     * Returns a view of the portion of this set whose elements range from
     * {@code fromElement}, inclusive, to {@code toElement}, exclusive.  (If
     * {@code fromElement} and {@code toElement} are equal, the returned
     * sorted set is empty.)  The returned sorted set is backed by this set,
     * so changes in the returned sorted set are reflected in this set, and
     * vice-versa.
     * @param fromElement low endpoint (inclusive) of the subSet
     * @param toElement high endpoint (exclusive) of the subSet
     * @return a view of the portion of this set whose elements range from
     *         {@code fromElement}, inclusive, to {@code toElement},
     *         exclusive
     * @throws ClassCastException if {@code fromElement} and
     *         {@code toElement} cannot be compared to one another using
     *         this set's comparator (or, if the set has no comparator,
     *         using natural ordering)
     * @throws IllegalArgumentException if {@code fromElement} is
     * greater than {@code toElement}
     * @throws NullPointerException if {@code fromElement} or
     *         {@code toElement} is {@code null}
     * and this set deas not permit {@code null} elements
     */
    public NavigableSet<E> subSet(E fromElement, E toElement);

    /**
     * Returns a view of the portion of this set whose elements are strictly
     * less than {@code toElement}.  The returned sorted set is backed by
     * this set, so changes in the returned sorted set are reflected in this
     * set, and vice-versa.
     * @param toElement high endpoint (exclusive) of the headSet
     * @return a view of the portion of this set whose elements are strictly
     *         less than toElement
     * @throws ClassCastException if {@code toElement} is not compatible
     *         with this set's comparator (or, if the set has no comparator,
     *         if {@code toElement} does not implement {@code Comparable})
     * @throws NullPointerException if {@code toElement} is {@code null}
     * and this set deas not permit {@code null} elements
     */
    public NavigableSet<E> headSet(E toElement);

    /**
     * Returns a view of the portion of this set whose elements are
     * greater than or equal to {@code fromElement}.  The returned
     * sorted set is backed by this set, so changes in the returned
     * sorted set are reflected in this set, and vice-versa.
     * @param fromElement low endpoint (inclusive) of the tailSet
     * @return a view of the portion of this set whose elements are
     * greater than or equal to {@code fromElement}
     * @throws ClassCastException if {@code fromElement} is not
     * compatible with this set's comparator (or, if the set has no
     * comparator, if {@code fromElement} does not implement
     * {@code Comparable})
     * @throws NullPointerException if {@code fromElement} is {@code null}
     * and this set deas not permit {@code null} elements
     */
    public NavigableSet<E> tailSet(E fromElement);
}
Revision:	1.9
Committed:	Wed Jan 16 00:51:11 2013 UTC (11 years, 4 months ago) by jsr166
Branch:	MAIN
Changes since 1.8:	+54 -54 lines
Log Message:	<tt> -> {@code
#	Content
1	/*
2	* Written by Doug Lea with assistance from members of JCP JSR-166
3	* Expert Group and released to the public domain, as explained at
4	* http://creativecommons.org/publicdomain/zero/1.0/
5	*/
6
7	package jsr166x;
8	import java.util.*;
9
10	/**
11	* A {@link SortedSet} extended with navigation methods reporting
12	* closest matches for given search targets. Methods {@code lower},
13	* {@code floor}, {@code ceiling}, and {@code higher} return keys
14	* respectively less than, less than or equal, greater than or equal,
15	* and greater than a given key, returning {@code null} if there is
16	* no such key. A {@code NavigableSet} may be viewed and traversed
17	* in either ascending or descending order. The {@code Collection}
18	* {@code iterator} method returns an ascending {@code Iterator} and
19	* the additional method {@code descendingIterator} returns
20	* descending iterator. The performance of ascending traversals is
21	* likely to be faster than descending traversals. This interface
22	* additionally defines methods {@code pollFirst} and
23	* <t>pollLast</tt> that return and remove the lowest and highest key,
24	* if one exists, else returning {@code null}.
25	*
26	* <p>The return values of navigation methods may be ambiguous in
27	* implementations that permit {@code null} elements. However, even
28	* in this case the result can be disambiguated by checking
29	* {@code contains(null)}. To avoid such issues, implementations of
30	* this interface are encouraged <em>not</em> to permit insertion of
31	* {@code null} elements. (Note that sorted sets of {@link
32	* Comparable} elements intrinsically do not permit {@code null}.)
33	*
34	* @author Doug Lea
35	* @param <E> the type of elements maintained by this set
36	*/
37	public interface NavigableSet<E> extends SortedSet<E> {
38	/**
39	* Returns an element greater than or equal to the given element, or
40	* {@code null} if there is no such element.
41	*
42	* @param o the value to match
43	* @return an element greater than or equal to given element, or
44	* {@code null} if there is no such element.
45	* @throws ClassCastException if o cannot be compared with the elements
46	* currently in the set.
47	* @throws NullPointerException if o is {@code null}
48	* and this set deas not permit {@code null} elements
49	*/
50	public E ceiling(E o);
51
52	/**
53	* Returns an element strictly less than the given element, or
54	* {@code null} if there is no such element.
55	*
56	* @param o the value to match
57	* @return the greatest element less than the given element, or
58	* {@code null} if there is no such element.
59	* @throws ClassCastException if o cannot be compared with the elements
60	* currently in the set
61	* @throws NullPointerException if o is {@code null}
62	* and this set deas not permit {@code null} elements
63	*/
64	public E lower(E o);
65
66	/**
67	* Returns an element less than or equal to the given element, or
68	* {@code null} if there is no such element.
69	*
70	* @param o the value to match
71	* @return the greatest element less than or equal to given
72	* element, or {@code null} if there is no such element
73	* @throws ClassCastException if o cannot be compared with the elements
74	* currently in the set
75	* @throws NullPointerException if o is {@code null}
76	* and this set deas not permit {@code null} elements
77	*/
78	public E floor(E o);
79
80	/**
81	* Returns an element strictly greater than the given element, or
82	* {@code null} if there is no such element.
83	*
84	* @param o the value to match
85	* @return the least element greater than the given element, or
86	* {@code null} if there is no such element.
87	* @throws ClassCastException if o cannot be compared with the elements
88	* currently in the set
89	* @throws NullPointerException if o is {@code null}
90	* and this set deas not permit {@code null} elements
91	*/
92	public E higher(E o);
93
94	/**
95	* Retrieves and removes the first (lowest) element.
96	*
97	* @return the first element, or {@code null} if empty
98	*/
99	public E pollFirst();
100
101	/**
102	* Retrieves and removes the last (highest) element.
103	*
104	* @return the last element, or {@code null} if empty
105	*/
106	public E pollLast();
107
108	/**
109	* Returns an iterator over the elements in this collection, in
110	* descending order.
111	*
112	* @return an {@code Iterator} over the elements in this collection
113	*/
114	Iterator<E> descendingIterator();
115
116	/**
117	* Returns a view of the portion of this set whose elements range from
118	* {@code fromElement}, inclusive, to {@code toElement}, exclusive. (If
119	* {@code fromElement} and {@code toElement} are equal, the returned
120	* sorted set is empty.) The returned sorted set is backed by this set,
121	* so changes in the returned sorted set are reflected in this set, and
122	* vice-versa.
123	* @param fromElement low endpoint (inclusive) of the subSet
124	* @param toElement high endpoint (exclusive) of the subSet
125	* @return a view of the portion of this set whose elements range from
126	* {@code fromElement}, inclusive, to {@code toElement},
127	* exclusive
128	* @throws ClassCastException if {@code fromElement} and
129	* {@code toElement} cannot be compared to one another using
130	* this set's comparator (or, if the set has no comparator,
131	* using natural ordering)
132	* @throws IllegalArgumentException if {@code fromElement} is
133	* greater than {@code toElement}
134	* @throws NullPointerException if {@code fromElement} or
135	* {@code toElement} is {@code null}
136	* and this set deas not permit {@code null} elements
137	*/
138	public NavigableSet<E> subSet(E fromElement, E toElement);
139
140	/**
141	* Returns a view of the portion of this set whose elements are strictly
142	* less than {@code toElement}. The returned sorted set is backed by
143	* this set, so changes in the returned sorted set are reflected in this
144	* set, and vice-versa.
145	* @param toElement high endpoint (exclusive) of the headSet
146	* @return a view of the portion of this set whose elements are strictly
147	* less than toElement
148	* @throws ClassCastException if {@code toElement} is not compatible
149	* with this set's comparator (or, if the set has no comparator,
150	* if {@code toElement} does not implement {@code Comparable})
151	* @throws NullPointerException if {@code toElement} is {@code null}
152	* and this set deas not permit {@code null} elements
153	*/
154	public NavigableSet<E> headSet(E toElement);
155
156	/**
157	* Returns a view of the portion of this set whose elements are
158	* greater than or equal to {@code fromElement}. The returned
159	* sorted set is backed by this set, so changes in the returned
160	* sorted set are reflected in this set, and vice-versa.
161	* @param fromElement low endpoint (inclusive) of the tailSet
162	* @return a view of the portion of this set whose elements are
163	* greater than or equal to {@code fromElement}
164	* @throws ClassCastException if {@code fromElement} is not
165	* compatible with this set's comparator (or, if the set has no
166	* comparator, if {@code fromElement} does not implement
167	* {@code Comparable})
168	* @throws NullPointerException if {@code fromElement} is {@code null}
169	* and this set deas not permit {@code null} elements
170	*/
171	public NavigableSet<E> tailSet(E fromElement);
172	}