/** * Factory method to create an unmodifiable set. * * @param <E> the element type * @param set the set to decorate, must not be null * @return a new unmodifiable {@link NavigableSet} * @throws NullPointerException if set is null */ public static <E> NavigableSet<E> unmodifiableNavigableSet(final NavigableSet<E> set) { if (set instanceof Unmodifiable) { return set; } return new UnmodifiableNavigableSet<>(set); }
@Override public NavigableSet<E> tailSet(final E fromElement, final boolean inclusive) { final NavigableSet<E> tail = decorated().tailSet(fromElement, inclusive); return unmodifiableNavigableSet(tail); }
/** * Read the collection in using a custom routine. * * @param in the input stream * @throws IOException if an error occurs while reading from the stream * @throws ClassNotFoundException if an object read from the stream can not be loaded */ @SuppressWarnings("unchecked") // (1) should only fail if input stream is incorrect private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); setCollection((Collection<E>) in.readObject()); // (1) }
/** * Write the collection out using a custom routine. * * @param out the output stream * @throws IOException if an error occurs while writing to the stream */ private void writeObject(final ObjectOutputStream out) throws IOException { out.defaultWriteObject(); out.writeObject(decorated()); }
/** * Returns an unmodifiable navigable set backed by the given navigable set. * <p> * This method uses the implementation in the decorators subpackage. * * @param <E> the element type * @param set the navigable set to make unmodifiable, must not be null * @return an unmodifiable set backed by the given set * @throws NullPointerException if the set is null * @since 4.1 */ public static <E> SortedSet<E> unmodifiableNavigableSet(final NavigableSet<E> set) { return UnmodifiableNavigableSet.unmodifiableNavigableSet(set); }
@Override public Iterator<E> iterator() { return UnmodifiableIterator.unmodifiableIterator(decorated().iterator()); }
@Override public NavigableSet<E> subSet(final E fromElement, final boolean fromInclusive, final E toElement, final boolean toInclusive) { final NavigableSet<E> sub = decorated().subSet(fromElement, fromInclusive, toElement, toInclusive); return unmodifiableNavigableSet(sub); }
@Override public SortedSet<E> subSet(final E fromElement, final E toElement) { final SortedSet<E> sub = decorated().subSet(fromElement, toElement); return UnmodifiableSortedSet.unmodifiableSortedSet(sub); }
@Override public NavigableSet<E> headSet(final E toElement, final boolean inclusive) { final NavigableSet<E> head = decorated().headSet(toElement, inclusive); return unmodifiableNavigableSet(head); }
@Override public SortedSet<E> headSet(final E toElement) { final SortedSet<E> head = decorated().headSet(toElement); return UnmodifiableSortedSet.unmodifiableSortedSet(head); }
@Override public NavigableSet<E> descendingSet() { return unmodifiableNavigableSet(decorated().descendingSet()); }
@Override public SortedSet<E> tailSet(final E fromElement) { final SortedSet<E> tail = decorated().tailSet(fromElement); return UnmodifiableSortedSet.unmodifiableSortedSet(tail); }
@Override public Iterator<E> descendingIterator() { return UnmodifiableIterator.unmodifiableIterator(decorated().descendingIterator()); }