/*
* @(#)SortedSet.java 1.24 06/10/10
*
* Copyright 1990-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License version
* 2 only, as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License version 2 for more details (a copy is
* included at /legal/license.txt).
*
* You should have received a copy of the GNU General Public License
* version 2 along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
* Clara, CA 95054 or visit www.sun.com if you need additional
* information or have any questions.
*
*/
package java.util;
/**
* A set that further guarantees that its iterator will traverse the set in
* ascending element order, sorted according to the <i>natural ordering</i> of
* its elements (see Comparable), or by a Comparator provided at sorted set
* creation time. Several additional operations are provided to take
* advantage of the ordering. (This interface is the set analogue of
* SortedMap.)<p>
*
* All elements inserted into an sorted set must implement the Comparable
* interface (or be accepted by the specified Comparator). Furthermore, all
* such elements must be <i>mutually comparable</i>: <tt>e1.compareTo(e2)</tt>
* (or <tt>comparator.compare(e1, e2)</tt>) must not throw a
* <tt>ClassCastException</tt> for any elements <tt>e1</tt> and <tt>e2</tt> in
* the sorted set. Attempts to violate this restriction will cause the
* offending method or constructor invocation to throw a
* <tt>ClassCastException</tt>.<p>
*
* Note that the ordering maintained by a sorted set (whether or not an
* explicit comparator is provided) must be <i>consistent with equals</i> if
* the sorted set is to correctly implement the <tt>Set</tt> interface. (See
* the <tt>Comparable</tt> interface or <tt>Comparator</tt> interface for a
* precise definition of <i>consistent with equals</i>.) This is so because
* the <tt>Set</tt> interface is defined in terms of the <tt>equals</tt>
* operation, but a sorted set performs all element comparisons using its
* <tt>compareTo</tt> (or <tt>compare</tt>) method, so two elements that are
* deemed equal by this method are, from the standpoint of the sorted set,
* equal. The behavior of a sorted set <i>is</i> well-defined even if its
* ordering is inconsistent with equals; it just fails to obey the general
* contract of the <tt>Set</tt> interface.<p>
*
* All general-purpose sorted set implementation classes should provide four
* "standard" constructors: 1) A void (no arguments) constructor, which
* creates an empty sorted set sorted according to the <i>natural order</i> of
* its elements. 2) A constructor with a single argument of type
* <tt>Comparator</tt>, which creates an empty sorted set sorted according to
* the specified comparator. 3) A constructor with a single argument of type
* <tt>Collection</tt>, which creates a new sorted set with the same elements
* as its argument, sorted according to the elements' natural ordering. 4) A
* constructor with a single argument of type <tt>SortedSet</tt>, which
* creates a new sorted set with the same elements and the same ordering as
* the input sorted set. There is no way to enforce this recommendation (as
* interfaces cannot contain constructors) but the SDK implementation (the
* <tt>TreeSet</tt> class) complies.<p>
*
* This interface is a member of the
* <a href="{@docRoot}/../guide/collections/index.html">
* Java Collections Framework</a>.
*
* @author Josh Bloch
* @version 1.15, 02/02/00
* @see Set
* @see TreeSet
* @see SortedMap
* @see Collection
* @see Comparable
* @see Comparator
* @see java.lang.ClassCastException
* @since 1.2
*/
public interface SortedSet extends Set {
/**
* Returns the comparator associated with this sorted set, or
* <tt>null</tt> if it uses its elements' natural ordering.
*
* @return the comparator associated with this sorted set, or
* <tt>null</tt> if it uses its elements' natural ordering.
*/
Comparator comparator();
/**
* Returns a view of the portion of this sorted set whose elements range
* from <tt>fromElement</tt>, inclusive, to <tt>toElement</tt>, exclusive.
* (If <tt>fromElement</tt> and <tt>toElement</tt> are equal, the returned
* sorted set is empty.) The returned sorted set is backed by this sorted
* set, so changes in the returned sorted set are reflected in this sorted
* set, and vice-versa. The returned sorted set supports all optional set
* operations that this sorted set supports.<p>
*
* The sorted set returned by this method will throw an
* <tt>IllegalArgumentException</tt> if the user attempts to insert a
* element outside the specified range.<p>
*
* Note: this method always returns a <i>half-open range</i> (which
* includes its low endpoint but not its high endpoint). If you need a
* <i>closed range</i> (which includes both endpoints), and the element
* type allows for calculation of the successor a given value, merely
* request the subrange from <tt>lowEndpoint</tt> to
* <tt>successor(highEndpoint)</tt>. For example, suppose that <tt>s</tt>
* is a sorted set of strings. The following idiom obtains a view
* containing all of the strings in <tt>s</tt> from <tt>low</tt> to
* <tt>high</tt>, inclusive: <pre>
* SortedSet sub = s.subSet(low, high+"\0");
* </pre>
*
* A similar technique can be used to generate an <i>open range</i> (which
* contains neither endpoint). The following idiom obtains a view
* containing all of the Strings in <tt>s</tt> from <tt>low</tt> to
* <tt>high</tt>, exclusive: <pre>
* SortedSet sub = s.subSet(low+"\0", high);
* </pre>
*
* @param fromElement low endpoint (inclusive) of the subSet.
* @param toElement high endpoint (exclusive) of the subSet.
* @return a view of the specified range within this sorted set.
*
* @throws ClassCastException if <tt>fromElement</tt> and
* <tt>toElement</tt> cannot be compared to one another using this
* set's comparator (or, if the set has no comparator, using
* natural ordering). Implementations may, but are not required
* to, throw this exception if <tt>fromElement</tt> or
* <tt>toElement</tt> cannot be compared to elements currently in
* the set.
* @throws IllegalArgumentException if <tt>fromElement</tt> is greater than
* <tt>toElement</tt>; or if this set is itself a subSet, headSet,
* or tailSet, and <tt>fromElement</tt> or <tt>toElement</tt> are
* not within the specified range of the subSet, headSet, or
* tailSet.
* @throws NullPointerException if <tt>fromElement</tt> or
* <tt>toElement</tt> is <tt>null</tt> and this sorted set does
* not tolerate <tt>null</tt> elements.
*/
SortedSet subSet(Object fromElement, Object toElement);
/**
* Returns a view of the portion of this sorted set whose elements are
* strictly less than <tt>toElement</tt>. The returned sorted set is
* backed by this sorted set, so changes in the returned sorted set are
* reflected in this sorted set, and vice-versa. The returned sorted set
* supports all optional set operations.<p>
*
* The sorted set returned by this method will throw an
* <tt>IllegalArgumentException</tt> if the user attempts to insert a
* element outside the specified range.<p>
*
* Note: this method always returns a view that does not contain its
* (high) endpoint. If you need a view that does contain this endpoint,
* and the element type allows for calculation of the successor a given
* value, merely request a headSet bounded by
* <tt>successor(highEndpoint)</tt>. For example, suppose that <tt>s</tt>
* is a sorted set of strings. The following idiom obtains a view
* containing all of the strings in <tt>s</tt> that are less than or equal
* to <tt>high</tt>:
* <pre> SortedSet head = s.headSet(high+"\0");</pre>
*
* @param toElement high endpoint (exclusive) of the headSet.
* @return a view of the specified initial range of this sorted set.
* @throws ClassCastException if <tt>toElement</tt> is not compatible
* with this set's comparator (or, if the set has no comparator,
* if <tt>toElement</tt> does not implement <tt>Comparable</tt>).
* Implementations may, but are not required to, throw this
* exception if <tt>toElement</tt> cannot be compared to elements
* currently in the set.
* @throws NullPointerException if <tt>toElement</tt> is <tt>null</tt> and
* this sorted set does not tolerate <tt>null</tt> elements.
* @throws IllegalArgumentException if this set is itself a subSet,
* headSet, or tailSet, and <tt>toElement</tt> is not within the
* specified range of the subSet, headSet, or tailSet.
*/
SortedSet headSet(Object toElement);
/**
* Returns a view of the portion of this sorted set whose elements are
* greater than or equal to <tt>fromElement</tt>. The returned sorted set
* is backed by this sorted set, so changes in the returned sorted set are
* reflected in this sorted set, and vice-versa. The returned sorted set
* supports all optional set operations.<p>
*
* The sorted set returned by this method will throw an
* <tt>IllegalArgumentException</tt> if the user attempts to insert a
* element outside the specified range.<p>
*
* Note: this method always returns a view that contains its (low)
* endpoint. If you need a view that does not contain this endpoint, and
* the element type allows for calculation of the successor a given value,
* merely request a tailSet bounded by <tt>successor(lowEndpoint)</tt>.
* For example, suppose that <tt>s</tt> is a sorted set of strings. The
* following idiom obtains a view containing all of the strings in
* <tt>s</tt> that are strictly greater than <tt>low</tt>:
*
* <pre> SortedSet tail = s.tailSet(low+"\0");</pre>
*
* @param fromElement low endpoint (inclusive) of the tailSet.
* @return a view of the specified final range of this sorted set.
* @throws ClassCastException if <tt>fromElement</tt> is not compatible
* with this set's comparator (or, if the set has no comparator,
* if <tt>fromElement</tt> does not implement <tt>Comparable</tt>).
* Implementations may, but are not required to, throw this
* exception if <tt>fromElement</tt> cannot be compared to elements
* currently in the set.
* @throws NullPointerException if <tt>fromElement</tt> is <tt>null</tt>
* and this sorted set does not tolerate <tt>null</tt> elements.
* @throws IllegalArgumentException if this set is itself a subSet,
* headSet, or tailSet, and <tt>fromElement</tt> is not within the
* specified range of the subSet, headSet, or tailSet.
*/
SortedSet tailSet(Object fromElement);
/**
* Returns the first (lowest) element currently in this sorted set.
*
* @return the first (lowest) element currently in this sorted set.
* @throws NoSuchElementException sorted set is empty.
*/
Object first();
/**
* Returns the last (highest) element currently in this sorted set.
*
* @return the last (highest) element currently in this sorted set.
* @throws NoSuchElementException sorted set is empty.
*/
Object last();
}