566 lines
19 KiB
Plaintext
566 lines
19 KiB
Plaintext
package speiger.src.collections.PACKAGE.utils;
|
|
|
|
#if TYPE_BOOLEAN
|
|
import speiger.src.collections.booleans.collections.BooleanIterator;
|
|
import speiger.src.collections.booleans.sets.AbstractBooleanSet;
|
|
import speiger.src.collections.booleans.sets.BooleanSet;
|
|
import speiger.src.collections.booleans.utils.BooleanCollections.EmptyCollection;
|
|
#else
|
|
#if TYPE_OBJECT
|
|
import java.util.Comparator;
|
|
|
|
#endif
|
|
import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
|
|
#if !TYPE_OBJECT
|
|
import speiger.src.collections.PACKAGE.functions.COMPARATOR;
|
|
#endif
|
|
import speiger.src.collections.PACKAGE.collections.ITERATOR;
|
|
import speiger.src.collections.PACKAGE.sets.NAVIGABLE_SET;
|
|
import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
|
|
import speiger.src.collections.PACKAGE.sets.SET;
|
|
import speiger.src.collections.PACKAGE.sets.SORTED_SET;
|
|
import speiger.src.collections.PACKAGE.utils.COLLECTIONS.EmptyCollection;
|
|
import speiger.src.collections.PACKAGE.utils.COLLECTIONS.SynchronizedCollection;
|
|
import speiger.src.collections.PACKAGE.utils.COLLECTIONS.UnmodifiableCollection;
|
|
import speiger.src.collections.utils.ITrimmable;
|
|
#endif
|
|
|
|
/**
|
|
* A Helper class for sets
|
|
*/
|
|
public class SETS
|
|
{
|
|
/**
|
|
* Empty Set Variable
|
|
*/
|
|
public static final SET NO_GENERIC_TYPE EMPTY = new EmptySetBRACES();
|
|
|
|
/**
|
|
* EmptySet getter
|
|
* @Type(T)
|
|
* @return a EmptySet
|
|
*/
|
|
public static GENERIC_KEY_BRACES SET KEY_GENERIC_TYPE empty() {
|
|
#if TYPE_OBJECT
|
|
return (SET<KEY_TYPE>)EMPTY;
|
|
#else
|
|
return EMPTY;
|
|
#endif
|
|
}
|
|
|
|
#if !TYPE_BOOLEAN
|
|
/**
|
|
* Creates a Synchronized set while preserving the ITrimmable interface
|
|
* @param s the set that should be synchronized
|
|
* @Type(T)
|
|
* @return a set that is synchronized
|
|
* @note if the set is already synchronized then it will just self return it
|
|
*/
|
|
public static GENERIC_KEY_BRACES SET KEY_GENERIC_TYPE synchronize(SET KEY_GENERIC_TYPE s) {
|
|
return s instanceof SynchronizedSet ? s : (s instanceof ITrimmable ? new SynchronizedTrimSetBRACES(s) : new SynchronizedSetBRACES(s));
|
|
}
|
|
|
|
/**
|
|
* Creates a Synchronized set while preserving the ITrimmable interface
|
|
* @param s the set that should be synchronized
|
|
* @param mutex controller for access
|
|
* @Type(T)
|
|
* @return a set that is synchronized
|
|
* @note if the set is already synchronized then it will just self return it
|
|
*/
|
|
public static GENERIC_KEY_BRACES SET KEY_GENERIC_TYPE synchronize(SET KEY_GENERIC_TYPE s, Object mutex) {
|
|
return s instanceof SynchronizedSet ? s : (s instanceof ITrimmable ? new SynchronizedTrimSetBRACES(s, mutex) : new SynchronizedSetBRACES(s, mutex));
|
|
}
|
|
|
|
/**
|
|
* Creates a Synchronized SortedSet while preserving the ITrimmable interface
|
|
* @param s the set that should be synchronized
|
|
* @Type(T)
|
|
* @return a SortedSet that is synchronized
|
|
* @note if the set is already synchronized then it will just self return it
|
|
*/
|
|
public static GENERIC_KEY_BRACES SORTED_SET KEY_GENERIC_TYPE synchronize(SORTED_SET KEY_GENERIC_TYPE s) {
|
|
return s instanceof SynchronizedSortedSet ? s : (s instanceof ITrimmable ? new SynchronizedSortedTrimSetBRACES(s) : new SynchronizedSortedSetBRACES(s));
|
|
}
|
|
|
|
/**
|
|
* Creates a Synchronized SortedSet while preserving the ITrimmable interface
|
|
* @param s the set that should be synchronized
|
|
* @param mutex controller for access
|
|
* @Type(T)
|
|
* @return a SortedSet that is synchronized
|
|
* @note if the set is already synchronized then it will just self return it
|
|
*/
|
|
public static GENERIC_KEY_BRACES SORTED_SET KEY_GENERIC_TYPE synchronize(SORTED_SET KEY_GENERIC_TYPE s, Object mutex) {
|
|
return s instanceof SynchronizedSortedSet ? s : (s instanceof ITrimmable ? new SynchronizedSortedTrimSetBRACES(s, mutex) : new SynchronizedSortedSetBRACES(s, mutex));
|
|
}
|
|
|
|
/**
|
|
* Creates a Synchronized NavigableSet while preserving the ITrimmable interface
|
|
* @param s the set that should be synchronized
|
|
* @Type(T)
|
|
* @return a NavigableSet that is synchronized
|
|
* @note if the set is already synchronized then it will just self return it
|
|
*/
|
|
public static GENERIC_KEY_BRACES NAVIGABLE_SET KEY_GENERIC_TYPE synchronize(NAVIGABLE_SET KEY_GENERIC_TYPE s) {
|
|
return s instanceof SynchronizedNavigableSet ? s : (s instanceof ITrimmable ? new SynchronizedNavigableTrimSetBRACES(s) : new SynchronizedNavigableSetBRACES(s));
|
|
}
|
|
|
|
/**
|
|
* Creates a Synchronized NavigableSet while preserving the ITrimmable interface
|
|
* @param s the set that should be synchronized
|
|
* @param mutex controller for access
|
|
* @Type(T)
|
|
* @return a NavigableSet that is synchronized
|
|
* @note if the set is already synchronized then it will just self return it
|
|
*/
|
|
public static GENERIC_KEY_BRACES NAVIGABLE_SET KEY_GENERIC_TYPE synchronize(NAVIGABLE_SET KEY_GENERIC_TYPE s, Object mutex) {
|
|
return s instanceof SynchronizedNavigableSet ? s : (s instanceof ITrimmable ? new SynchronizedNavigableTrimSetBRACES(s, mutex) : new SynchronizedNavigableSetBRACES(s, mutex));
|
|
}
|
|
|
|
/**
|
|
* Creates Unmodifyable Set wrapper
|
|
* @param s set that should be made unmodifiable
|
|
* @Type(T)
|
|
* @return a UnmodifyableSet, if the set is already unmodifiable then it returns itself
|
|
*/
|
|
public static GENERIC_KEY_BRACES SET KEY_GENERIC_TYPE unmodifiable(SET KEY_GENERIC_TYPE s) {
|
|
return s instanceof UnmodifiableSet ? s : new UnmodifiableSetBRACES(s);
|
|
}
|
|
|
|
/**
|
|
* Creates Unmodifyable SortedSet wrapper
|
|
* @param s sortedSet that should be made unmodifiable
|
|
* @Type(T)
|
|
* @return a UnmodifyableSortedSet, if the set is already unmodifiable then it returns itself
|
|
*/
|
|
public static GENERIC_KEY_BRACES SORTED_SET KEY_GENERIC_TYPE unmodifiable(SORTED_SET KEY_GENERIC_TYPE s) {
|
|
return s instanceof UnmodifiableSortedSet ? s : new UnmodifiableSortedSetBRACES(s);
|
|
}
|
|
|
|
/**
|
|
* Creates Unmodifyable NavigableSet wrapper
|
|
* @param s navigableSet that should be made unmodifiable
|
|
* @Type(T)
|
|
* @return a UnmodifyableNavigableSet, if the set is already unmodifiable then it returns itself
|
|
*/
|
|
public static GENERIC_KEY_BRACES NAVIGABLE_SET KEY_GENERIC_TYPE unmodifiable(NAVIGABLE_SET KEY_GENERIC_TYPE s) {
|
|
return s instanceof UnmodifiableNavigableSet ? s : new UnmodifiableNavigableSetBRACES(s);
|
|
}
|
|
|
|
#endif
|
|
/**
|
|
* Creates a Singleton set of a given element
|
|
* @param element the element that should be converted into a singleton set
|
|
* @Type(T)
|
|
* @return a singletonset of the given element
|
|
*/
|
|
public static GENERIC_KEY_BRACES SET KEY_GENERIC_TYPE singleton(KEY_TYPE element) {
|
|
return new SingletonSetBRACES(element);
|
|
}
|
|
|
|
private static class SingletonSet KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE
|
|
{
|
|
KEY_TYPE element;
|
|
|
|
SingletonSet(KEY_TYPE element) {
|
|
this.element = element;
|
|
}
|
|
|
|
#if !TYPE_OBJECT
|
|
@Override
|
|
public boolean remove(KEY_TYPE o) { throw new UnsupportedOperationException(); }
|
|
#endif
|
|
@Override
|
|
public boolean add(KEY_TYPE o) { throw new UnsupportedOperationException(); }
|
|
@Override
|
|
public ITERATOR KEY_GENERIC_TYPE iterator()
|
|
{
|
|
return new ITERATOR KEY_GENERIC_TYPE() {
|
|
boolean next = true;
|
|
@Override
|
|
public boolean hasNext() { return next = false; }
|
|
@Override
|
|
public KEY_TYPE NEXT() {
|
|
if(!next) throw new IllegalStateException();
|
|
next = false;
|
|
return element;
|
|
}
|
|
};
|
|
}
|
|
@Override
|
|
public int size() { return 1; }
|
|
}
|
|
|
|
private static class EmptySet KEY_GENERIC_TYPE extends EmptyCollection KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
|
|
{
|
|
#if !TYPE_OBJECT
|
|
@Override
|
|
public boolean remove(KEY_TYPE o) { throw new UnsupportedOperationException(); }
|
|
#endif
|
|
}
|
|
|
|
#if !TYPE_BOOLEAN
|
|
private static class UnmodifiableNavigableSet KEY_GENERIC_TYPE extends UnmodifiableSortedSet KEY_GENERIC_TYPE implements NAVIGABLE_SET KEY_GENERIC_TYPE
|
|
{
|
|
NAVIGABLE_SET KEY_GENERIC_TYPE n;
|
|
|
|
UnmodifiableNavigableSet(NAVIGABLE_SET KEY_GENERIC_TYPE c) {
|
|
super(c);
|
|
n = c;
|
|
}
|
|
|
|
#if !TYPE_OBJECT
|
|
@Override
|
|
public boolean contains(KEY_TYPE o) { return n.contains(o); }
|
|
|
|
#endif
|
|
@Override
|
|
@Deprecated
|
|
public boolean contains(Object o) { return n.contains(o); }
|
|
|
|
@Override
|
|
public KEY_TYPE lower(KEY_TYPE e) { return n.lower(e); }
|
|
|
|
@Override
|
|
public KEY_TYPE floor(KEY_TYPE e) { return n.floor(e); }
|
|
|
|
@Override
|
|
public KEY_TYPE ceiling(KEY_TYPE e) { return n.ceiling(e); }
|
|
|
|
@Override
|
|
public KEY_TYPE higher(KEY_TYPE e) { return n.higher(e); }
|
|
|
|
#if !TYPE_OBJECT
|
|
@Override
|
|
public void setDefaultMaxValue(KEY_TYPE e) { throw new UnsupportedOperationException(); }
|
|
|
|
@Override
|
|
public KEY_TYPE getDefaultMaxValue() { return n.getDefaultMaxValue(); }
|
|
|
|
@Override
|
|
public void setDefaultMinValue(KEY_TYPE e) { throw new UnsupportedOperationException(); }
|
|
|
|
@Override
|
|
public KEY_TYPE getDefaultMinValue() { return n.getDefaultMinValue(); }
|
|
|
|
#endif
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) { return unmodifiable(n.subSet(fromElement, fromInclusive, toElement, toInclusive)); }
|
|
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement, boolean inclusive) { return unmodifiable(n.headSet(toElement, inclusive)); }
|
|
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement, boolean inclusive) { return unmodifiable(n.tailSet(fromElement, inclusive)); }
|
|
|
|
@Override
|
|
public BI_ITERATOR KEY_GENERIC_TYPE descendingIterator() { return ITERATORS.unmodifiable(n.descendingIterator()); }
|
|
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE descendingSet() { return unmodifiable(n.descendingSet()); }
|
|
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { return unmodifiable(n.subSet(fromElement, toElement)); }
|
|
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { return unmodifiable(n.headSet(toElement)); }
|
|
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { return unmodifiable(n.tailSet(fromElement)); }
|
|
}
|
|
|
|
private static class UnmodifiableSortedSet KEY_GENERIC_TYPE extends UnmodifiableSet KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE
|
|
{
|
|
SORTED_SET KEY_GENERIC_TYPE s;
|
|
UnmodifiableSortedSet(SORTED_SET KEY_GENERIC_TYPE c)
|
|
{
|
|
super(c);
|
|
s = c;
|
|
}
|
|
|
|
@Override
|
|
public boolean addAndMoveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
|
|
|
|
@Override
|
|
public boolean addAndMoveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
|
|
|
|
@Override
|
|
public boolean moveToFirst(KEY_TYPE o) { throw new UnsupportedOperationException(); }
|
|
|
|
@Override
|
|
public boolean moveToLast(KEY_TYPE o) { throw new UnsupportedOperationException(); }
|
|
|
|
@Override
|
|
public COMPARATOR KEY_GENERIC_TYPE comparator() { return s.comparator(); }
|
|
|
|
@Override
|
|
public BI_ITERATOR KEY_GENERIC_TYPE iterator() { return ITERATORS.unmodifiable(s.iterator()); }
|
|
|
|
@Override
|
|
public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { return ITERATORS.unmodifiable(s.iterator(fromElement)); }
|
|
|
|
@Override
|
|
public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { return unmodifiable(s.subSet(fromElement, toElement)); }
|
|
|
|
@Override
|
|
public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { return unmodifiable(s.headSet(toElement)); }
|
|
|
|
@Override
|
|
public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { return unmodifiable(s.tailSet(fromElement)); }
|
|
|
|
@Override
|
|
public KEY_TYPE FIRST_KEY() { return s.FIRST_KEY(); }
|
|
|
|
@Override
|
|
public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); }
|
|
|
|
@Override
|
|
public KEY_TYPE LAST_KEY() { return s.LAST_KEY(); }
|
|
|
|
@Override
|
|
public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); }
|
|
}
|
|
|
|
/**
|
|
* Unmodifyable Set wrapper that helps is used with unmodifyableSet function
|
|
* @Type(T)
|
|
*/
|
|
public static class UnmodifiableSet KEY_GENERIC_TYPE extends UnmodifiableCollection KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
|
|
{
|
|
SET KEY_GENERIC_TYPE s;
|
|
|
|
protected UnmodifiableSet(SET KEY_GENERIC_TYPE c)
|
|
{
|
|
super(c);
|
|
s = c;
|
|
}
|
|
|
|
#if !TYPE_OBJECT
|
|
@Override
|
|
public boolean remove(KEY_TYPE o) { throw new UnsupportedOperationException(); }
|
|
#endif
|
|
}
|
|
|
|
private static class SynchronizedNavigableTrimSet KEY_GENERIC_TYPE extends SynchronizedNavigableSet KEY_GENERIC_TYPE implements ITrimmable
|
|
{
|
|
ITrimmable trim;
|
|
|
|
SynchronizedNavigableTrimSet(NAVIGABLE_SET KEY_GENERIC_TYPE c) {
|
|
super(c);
|
|
trim = (ITrimmable)c;
|
|
}
|
|
|
|
SynchronizedNavigableTrimSet(NAVIGABLE_SET KEY_GENERIC_TYPE c, Object mutex) {
|
|
super(c, mutex);
|
|
trim = (ITrimmable)c;
|
|
}
|
|
|
|
@Override
|
|
public boolean trim(int size) { synchronized(mutex) { return trim.trim(size); } }
|
|
|
|
@Override
|
|
public void clearAndTrim(int size) { synchronized(mutex) { trim.clearAndTrim(size); } }
|
|
}
|
|
|
|
private static class SynchronizedNavigableSet KEY_GENERIC_TYPE extends SynchronizedSortedSet KEY_GENERIC_TYPE implements NAVIGABLE_SET KEY_GENERIC_TYPE
|
|
{
|
|
NAVIGABLE_SET KEY_GENERIC_TYPE n;
|
|
|
|
SynchronizedNavigableSet(NAVIGABLE_SET KEY_GENERIC_TYPE c) {
|
|
super(c);
|
|
n = c;
|
|
}
|
|
|
|
SynchronizedNavigableSet(NAVIGABLE_SET KEY_GENERIC_TYPE c, Object mutex) {
|
|
super(c, mutex);
|
|
n = c;
|
|
}
|
|
|
|
@Override
|
|
@Deprecated
|
|
public boolean contains(Object o) { synchronized(mutex) { return n.contains(o); } }
|
|
|
|
#if !TYPE_OBJECT
|
|
@Override
|
|
public boolean contains(KEY_TYPE o) { synchronized(mutex) { return n.contains(o); } }
|
|
|
|
#endif
|
|
@Override
|
|
public KEY_TYPE lower(KEY_TYPE e) { synchronized(mutex) { return n.lower(e); } }
|
|
|
|
@Override
|
|
public KEY_TYPE floor(KEY_TYPE e) { synchronized(mutex) { return n.floor(e); } }
|
|
|
|
@Override
|
|
public KEY_TYPE ceiling(KEY_TYPE e) { synchronized(mutex) { return n.ceiling(e); } }
|
|
|
|
@Override
|
|
public KEY_TYPE higher(KEY_TYPE e) { synchronized(mutex) { return n.higher(e); } }
|
|
|
|
#if !TYPE_OBJECT
|
|
@Override
|
|
public void setDefaultMaxValue(KEY_TYPE e) { synchronized(mutex) { n.setDefaultMaxValue(e); } }
|
|
|
|
@Override
|
|
public KEY_TYPE getDefaultMaxValue() { synchronized(mutex) { return n.getDefaultMaxValue(); } }
|
|
|
|
@Override
|
|
public void setDefaultMinValue(KEY_TYPE e) { synchronized(mutex) { n.setDefaultMinValue(e); } }
|
|
|
|
@Override
|
|
public KEY_TYPE getDefaultMinValue() { synchronized(mutex) { return n.getDefaultMinValue(); } }
|
|
|
|
#endif
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) { synchronized(mutex) { return synchronize(n.subSet(fromElement, fromInclusive, toElement, toInclusive), mutex); } }
|
|
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement, boolean inclusive) { synchronized(mutex) { return synchronize(n.headSet(toElement, inclusive), mutex); } }
|
|
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement, boolean inclusive) { synchronized(mutex) { return synchronize(n.tailSet(fromElement, inclusive), mutex); } }
|
|
|
|
@Override
|
|
public BI_ITERATOR KEY_GENERIC_TYPE descendingIterator() { synchronized(mutex) { return n.descendingIterator(); } }
|
|
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE descendingSet() { synchronized(mutex) { return synchronize(n.descendingSet(), mutex); } }
|
|
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { synchronized(mutex) { return synchronize(n.subSet(fromElement, toElement), mutex); } }
|
|
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { synchronized(mutex) { return synchronize(n.headSet(toElement), mutex); } }
|
|
|
|
@Override
|
|
public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { synchronized(mutex) { return synchronize(n.tailSet(fromElement), mutex); } }
|
|
}
|
|
|
|
private static class SynchronizedSortedTrimSet KEY_GENERIC_TYPE extends SynchronizedSortedSet KEY_GENERIC_TYPE implements ITrimmable
|
|
{
|
|
ITrimmable trim;
|
|
|
|
SynchronizedSortedTrimSet(SORTED_SET KEY_GENERIC_TYPE c) {
|
|
super(c);
|
|
trim = (ITrimmable)c;
|
|
}
|
|
|
|
SynchronizedSortedTrimSet(SORTED_SET KEY_GENERIC_TYPE c, Object mutex) {
|
|
super(c, mutex);
|
|
trim = (ITrimmable)c;
|
|
}
|
|
|
|
@Override
|
|
public boolean trim(int size) { synchronized(mutex) { return trim.trim(size); } }
|
|
|
|
@Override
|
|
public void clearAndTrim(int size) { synchronized(mutex) { trim.clearAndTrim(size); } }
|
|
}
|
|
|
|
private static class SynchronizedSortedSet KEY_GENERIC_TYPE extends SynchronizedSet KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE
|
|
{
|
|
SORTED_SET KEY_GENERIC_TYPE s;
|
|
|
|
SynchronizedSortedSet(SORTED_SET KEY_GENERIC_TYPE c) {
|
|
super(c);
|
|
s = c;
|
|
}
|
|
|
|
SynchronizedSortedSet(SORTED_SET KEY_GENERIC_TYPE c, Object mutex) {
|
|
super(c, mutex);
|
|
s = c;
|
|
}
|
|
|
|
@Override
|
|
public boolean addAndMoveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToFirst(o); } }
|
|
|
|
@Override
|
|
public boolean addAndMoveToLast(KEY_TYPE o) { synchronized(mutex) { return s.addAndMoveToLast(o); } }
|
|
|
|
@Override
|
|
public boolean moveToFirst(KEY_TYPE o) { synchronized(mutex) { return s.moveToFirst(o); } }
|
|
|
|
@Override
|
|
public boolean moveToLast(KEY_TYPE o) { synchronized(mutex) { return s.moveToLast(o); } }
|
|
|
|
@Override
|
|
public COMPARATOR KEY_GENERIC_TYPE comparator(){ synchronized(mutex) { return s.comparator(); } }
|
|
|
|
@Override
|
|
public BI_ITERATOR KEY_GENERIC_TYPE iterator() { synchronized(mutex) { return s.iterator(); } }
|
|
|
|
@Override
|
|
public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { synchronized(mutex) { return s.iterator(fromElement); } }
|
|
|
|
@Override
|
|
public SORTED_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { synchronized(mutex) { return synchronize(s.subSet(fromElement, toElement), mutex); } }
|
|
|
|
@Override
|
|
public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { synchronized(mutex) { return synchronize(s.headSet(toElement), mutex); } }
|
|
|
|
@Override
|
|
public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { synchronized(mutex) { return synchronize(s.tailSet(fromElement), mutex); } }
|
|
|
|
@Override
|
|
public KEY_TYPE FIRST_KEY() { synchronized(mutex) { return s.FIRST_KEY(); } }
|
|
|
|
@Override
|
|
public KEY_TYPE POLL_FIRST_KEY() { synchronized(mutex) { return s.POLL_FIRST_KEY(); } }
|
|
|
|
@Override
|
|
public KEY_TYPE LAST_KEY() { synchronized(mutex) { return s.LAST_KEY(); } }
|
|
|
|
@Override
|
|
public KEY_TYPE POLL_LAST_KEY() { synchronized(mutex) { return s.POLL_LAST_KEY(); } }
|
|
}
|
|
|
|
private static class SynchronizedTrimSet KEY_GENERIC_TYPE extends SynchronizedSet KEY_GENERIC_TYPE implements ITrimmable
|
|
{
|
|
ITrimmable trim;
|
|
|
|
SynchronizedTrimSet(SET KEY_GENERIC_TYPE c) {
|
|
super(c);
|
|
trim = (ITrimmable)c;
|
|
}
|
|
|
|
SynchronizedTrimSet(SET KEY_GENERIC_TYPE c, Object mutex) {
|
|
super(c, mutex);
|
|
trim = (ITrimmable)c;
|
|
}
|
|
|
|
@Override
|
|
public boolean trim(int size) { synchronized(mutex) { return trim.trim(size); } }
|
|
|
|
@Override
|
|
public void clearAndTrim(int size) { synchronized(mutex) { trim.clearAndTrim(size); } }
|
|
}
|
|
|
|
private static class SynchronizedSet KEY_GENERIC_TYPE extends SynchronizedCollection KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
|
|
{
|
|
#if !TYPE_OBJECT
|
|
SET KEY_GENERIC_TYPE s;
|
|
#endif
|
|
|
|
SynchronizedSet(SET KEY_GENERIC_TYPE c) {
|
|
super(c);
|
|
#if !TYPE_OBJECT
|
|
s = c;
|
|
#endif
|
|
}
|
|
|
|
SynchronizedSet(SET KEY_GENERIC_TYPE c, Object mutex) {
|
|
super(c, mutex);
|
|
#if !TYPE_OBJECT
|
|
s = c;
|
|
#endif
|
|
}
|
|
|
|
#if !TYPE_OBJECT
|
|
@Override
|
|
public boolean remove(KEY_TYPE o) { synchronized(mutex) { return s.remove(o); } }
|
|
#endif
|
|
}
|
|
#endif
|
|
}
|