/**
* Factory method to create an unmodifiable set.
*
* @param set the set to decorate, must not be null
* @throws IllegalArgumentException if set is null
*/
public static java.util.SortedSet <Object> decorate(java.util.SortedSet <Object> set)
{
if (set is Unmodifiable)
{
return(set);
}
return(new UnmodifiableSortedSet(set));
}
public java.util.SortedSet <Object> headSet(Object toElement)
{
lock (lockJ)
{
java.util.SortedSet <Object> set = getSortedSet().headSet(toElement);
// the lock is passed into the constructor here to ensure that the
// headset is synchronized on the same lock as the parent
return(new SynchronizedSortedSet(set, lockJ));
}
}
public java.util.SortedSet <Object> headSet(Object toElement)
{
java.util.SortedSet <Object> set = getSortedSet().headSet(toElement);
return(new TransformedSortedSet(set, transformer));
}
//-----------------------------------------------------------------------
/**
* Constructor that wraps (not copies).
*
* @param set the set to decorate, must not be null
* @throws IllegalArgumentException if set is null
*/
private UnmodifiableSortedSet(java.util.SortedSet <Object> set)
: base(set)
{
}
public override java.util.SortedSet <Object> tailSet(Object fromElement)
{
java.util.SortedSet <Object> sub = getSortedSet().tailSet(fromElement);
return(new UnmodifiableSortedSet(sub));
}
public override java.util.SortedSet <Object> headSet(Object toElement)
{
java.util.SortedSet <Object> sub = getSortedSet().headSet(toElement);
return(new UnmodifiableSortedSet(sub));
}
//-----------------------------------------------------------------------
public java.util.SortedSet <Object> subSet(Object fromElement, Object toElement)
{
java.util.SortedSet <Object> sub = getSortedSet().subSet(fromElement, toElement);
return(new PredicatedSortedSet(sub, predicate));
}
//-----------------------------------------------------------------------
/**
* Constructor that wraps (not copies).
* <p>
* If there are any elements already in the set being decorated, they
* are NOT transformed.
*
* @param set the set to decorate, must not be null
* @param transformer the transformer to use for conversion, must not be null
* @throws IllegalArgumentException if set or transformer is null
*/
protected TransformedSortedSet(java.util.SortedSet <Object> set, Transformer transformer)
: base(set, transformer)
{
}
/**
* Returns an unmodifiable sorted set backed by the given sorted set.
* <p>
* This method uses the implementation in the decorators subpackage.
*
* @param set the sorted set to make unmodifiable, must not be null
* @return an unmodifiable set backed by the given set
* @throws IllegalArgumentException if the set is null
*/
public static java.util.SortedSet <Object> unmodifiableSortedSet(java.util.SortedSet <Object> set)
{
return(UnmodifiableSortedSet.decorate(set));
}
//-----------------------------------------------------------------------
/**
* Returns a synchronized sorted set backed by the given sorted set.
* <p>
* You must manually synchronize on the returned buffer's iterator to
* avoid non-deterministic behavior:
*
* <pre>
* Set s = SetUtils.synchronizedSet(mySet);
* synchronized (s) {
* Iterator i = s.iterator();
* while (i.hasNext()) {
* process (i.next());
* }
* }
* </pre>
*
* This method uses the implementation in the decorators subpackage.
*
* @param set the sorted set to synchronize, must not be null
* @return a synchronized set backed by the given set
* @throws IllegalArgumentException if the set is null
*/
public static java.util.SortedSet <Object> synchronizedSortedSet(java.util.SortedSet <Object> set)
{
return(SynchronizedSortedSet.decorate(set));
}
/**
* Constructor that wraps (not copies).
*
* @param set the set to decorate, must not be null
* @param lock the lock object to use, must not be null
* @throws IllegalArgumentException if set is null
*/
protected SynchronizedSortedSet(java.util.SortedSet <Object> set, Object lockJ)
: base(set, lockJ)
{
}
//-----------------------------------------------------------------------
/**
* Constructor that wraps (not copies).
*
* @param set the set to decorate, must not be null
* @throws IllegalArgumentException if set is null
*/
protected SynchronizedSortedSet(java.util.SortedSet <Object> set)
: base(set)
{
}
public java.util.SortedSet <Object> headSet(Object toElement)
{
java.util.SortedSet <Object> sub = getSortedSet().headSet(toElement);
return(new PredicatedSortedSet(sub, predicate));
}
public java.util.SortedSet <Object> tailSet(Object fromElement)
{
java.util.SortedSet <Object> set = getSortedSet().tailSet(fromElement);
return(new TransformedSortedSet(set, transformer));
}
/**
* Returns a predicated (validating) sorted set backed by the given sorted set.
* <p>
* Only objects that pass the test in the given predicate can be added to the set.
* Trying to add an invalid object results in an IllegalArgumentException.
* It is important not to use the original set after invoking this method,
* as it is a backdoor for adding invalid objects.
*
* @param set the sorted set to predicate, must not be null
* @param predicate the predicate for the sorted set, must not be null
* @return a predicated sorted set backed by the given sorted set
* @throws IllegalArgumentException if the Set or Predicate is null
*/
public static java.util.SortedSet <Object> predicatedSortedSet(java.util.SortedSet <Object> set, Predicate predicate)
{
return(PredicatedSortedSet.decorate(set, predicate));
}
/**
* Factory method to create a transforming sorted set.
* <p>
* If there are any elements already in the set being decorated, they
* are NOT transformed.
*
* @param set the set to decorate, must not be null
* @param transformer the transformer to use for conversion, must not be null
* @throws IllegalArgumentException if set or transformer is null
*/
public static java.util.SortedSet <Object> decorate(java.util.SortedSet <Object> set, Transformer transformer)
{
return(new TransformedSortedSet(set, transformer));
}
/**
* Returns a typed sorted set backed by the given set.
* <p>
* Only objects of the specified type can be added to the set.
*
* @param set the set to limit to a specific type, must not be null
* @param type the type of objects which may be added to the set
* @return a typed set backed by the specified set
*/
public static java.util.SortedSet <Object> typedSortedSet(java.util.SortedSet <Object> set, java.lang.Class type)
{
return(TypedSortedSet.decorate(set, type));
}
/**
* Factory method to create a typed sorted set.
* <p>
* If there are any elements already in the set being decorated, they
* are validated.
*
* @param set the set to decorate, must not be null
* @param type the type to allow into the collection, must not be null
* @throws IllegalArgumentException if set or type is null
* @throws IllegalArgumentException if the set contains invalid elements
*/
public static java.util.SortedSet <Object> decorate(java.util.SortedSet <Object> set, java.lang.Class type)
{
return(new PredicatedSortedSet(set, InstanceofPredicate.getInstance(type)));
}
//-----------------------------------------------------------------------
/**
* Constructor that wraps (not copies).
* <p>
* If there are any elements already in the set being decorated, they
* are validated.
*
* @param set the set to decorate, must not be null
* @param predicate the predicate to use for validation, must not be null
* @throws IllegalArgumentException if set or predicate is null
* @throws IllegalArgumentException if the set contains invalid elements
*/
protected internal PredicatedSortedSet(java.util.SortedSet <Object> set, Predicate predicate)
: base(set, predicate)
{
}
