forked from Speiger/Primitive-Collections
Fixed Bugs and Completion of Sets
-Added: AVLTreeSet -Added: Sets -Changed: Boolean has all Set classes disabled (For Now)
This commit is contained in:
parent
4e89ec946f
commit
787a154042
|
|
@ -79,6 +79,7 @@ public class GlobalVariables
|
|||
addClassMapper("CUSTOM_HASH_SET", "OpenCustomHashSet");
|
||||
addClassMapper("HASH_SET", "OpenHashSet");
|
||||
addClassMapper("RB_TREE_SET", "RBTreeSet");
|
||||
addClassMapper("AVL_TREE_SET", "AVLTreeSet");
|
||||
addClassMapper("ARRAY_SET", "ArraySet");
|
||||
|
||||
//Abstract Classes
|
||||
|
|
@ -89,6 +90,7 @@ public class GlobalVariables
|
|||
|
||||
//Helper Classes
|
||||
addClassMapper("LISTS", "Lists");
|
||||
addClassMapper("SETS", "Sets");
|
||||
addClassMapper("COLLECTIONS", "Collections");
|
||||
addClassMapper("ARRAYS", "Arrays");
|
||||
addClassMapper("ITERATORS", "Iterators");
|
||||
|
|
|
|||
|
|
@ -20,7 +20,6 @@ public class TestBuilder extends TemplateProcessor
|
|||
public static final ClassType[] TYPE = ClassType.values();
|
||||
List<GlobalVariables> varibles = new ArrayList<GlobalVariables>();
|
||||
|
||||
|
||||
public TestBuilder()
|
||||
{
|
||||
super(Paths.get("src\\main\\resources\\speiger\\assets\\collections\\templates\\"), Paths.get("src\\main\\java\\speiger\\src\\collections\\"), Paths.get("src\\main\\resources\\speiger\\assets\\collections\\"));
|
||||
|
|
@ -59,6 +58,17 @@ public class TestBuilder extends TemplateProcessor
|
|||
blocked.put("Consumer", EnumSet.of(ClassType.OBJECT));
|
||||
blocked.put("Comparator", EnumSet.of(ClassType.OBJECT));
|
||||
blocked.put("Stack", EnumSet.of(ClassType.OBJECT));
|
||||
blocked.put("Sets", EnumSet.of(ClassType.BOOLEAN));
|
||||
blocked.put("ArraySet", EnumSet.of(ClassType.BOOLEAN));
|
||||
blocked.put("AVLTreeSet", EnumSet.of(ClassType.BOOLEAN));
|
||||
blocked.put("RBTreeSet", EnumSet.of(ClassType.BOOLEAN));
|
||||
blocked.put("RBTreeSet", EnumSet.of(ClassType.BOOLEAN));
|
||||
blocked.put("SortedSet", EnumSet.of(ClassType.BOOLEAN));
|
||||
blocked.put("NavigableSet", EnumSet.of(ClassType.BOOLEAN));
|
||||
blocked.put("OpenHashSet", EnumSet.of(ClassType.BOOLEAN));
|
||||
blocked.put("OpenCustomHashSet", EnumSet.of(ClassType.BOOLEAN));
|
||||
blocked.put("LinkedOpenHashSet", EnumSet.of(ClassType.BOOLEAN));
|
||||
blocked.put("LinkedOpenCustomHashSet", EnumSet.of(ClassType.BOOLEAN));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -0,0 +1,994 @@
|
|||
package speiger.src.collections.PACKAGE.sets;
|
||||
|
||||
import java.util.NoSuchElementException;
|
||||
#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.lists.LIST_ITERATOR;
|
||||
|
||||
public class AVL_TREE_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements NAVIGABLE_SET KEY_GENERIC_TYPE
|
||||
{
|
||||
protected transient Entry KEY_GENERIC_TYPE tree;
|
||||
protected transient Entry KEY_GENERIC_TYPE first;
|
||||
protected transient Entry KEY_GENERIC_TYPE last;
|
||||
protected int size = 0;
|
||||
protected transient COMPARATOR KEY_GENERIC_TYPE comparator;
|
||||
#if !TYPE_OBJECT
|
||||
#if TYPE_BOOLEAN
|
||||
protected KEY_TYPE defaultMaxNotFound = CLASS_TYPE.FALSE;
|
||||
protected KEY_TYPE defaultMinNotFound = CLASS_TYPE.TRUE;
|
||||
#else
|
||||
protected KEY_TYPE defaultMaxNotFound = CLASS_TYPE.MIN_VALUE;
|
||||
protected KEY_TYPE defaultMinNotFound = CLASS_TYPE.MAX_VALUE;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
public AVL_TREE_SET() {
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public void setDefaultMaxValue(KEY_TYPE value) { defaultMaxNotFound = value; }
|
||||
@Override
|
||||
public KEY_TYPE getDefaultMaxValue() { return defaultMaxNotFound; }
|
||||
@Override
|
||||
public void setDefaultMinValue(KEY_TYPE value) { defaultMinNotFound = value; }
|
||||
@Override
|
||||
public KEY_TYPE getDefaultMinValue() { return defaultMinNotFound; }
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public boolean add(KEY_TYPE o) {
|
||||
if(tree == null) {
|
||||
tree = first = last = new EntryBRACES(o, null);
|
||||
size++;
|
||||
return true;
|
||||
}
|
||||
int compare = 0;
|
||||
Entry KEY_GENERIC_TYPE parent = tree;
|
||||
while(true) {
|
||||
if((compare = compare(o, parent.key)) == 0) return false;
|
||||
if(compare < 0) {
|
||||
if(parent.left == null) break;
|
||||
parent = parent.left;
|
||||
}
|
||||
else if(compare > 0) {
|
||||
if(parent.right == null) break;
|
||||
parent = parent.right;
|
||||
}
|
||||
}
|
||||
Entry KEY_GENERIC_TYPE adding = new EntryBRACES(o, parent);
|
||||
if(compare < 0) {
|
||||
parent.left = adding;
|
||||
if(parent == first) first = adding;
|
||||
}
|
||||
else {
|
||||
parent.right = adding;
|
||||
if(parent == last) last = adding;
|
||||
}
|
||||
fixAfterInsertion(adding);
|
||||
size++;
|
||||
return false;
|
||||
}
|
||||
|
||||
@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 KEY_TYPE lower(KEY_TYPE e) {
|
||||
Entry KEY_GENERIC_TYPE node = findLowerNode(e);
|
||||
#if TYPE_OBJECT
|
||||
return node != null ? node.key : null;
|
||||
#else
|
||||
return node != null ? node.key : defaultMinNotFound;
|
||||
#endif
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE floor(KEY_TYPE e) {
|
||||
Entry KEY_GENERIC_TYPE node = findFloorNode(e);
|
||||
#if TYPE_OBJECT
|
||||
return node != null ? node.key : null;
|
||||
#else
|
||||
return node != null ? node.key : defaultMinNotFound;
|
||||
#endif
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE higher(KEY_TYPE e) {
|
||||
Entry KEY_GENERIC_TYPE node = findHigherNode(e);
|
||||
#if TYPE_OBJECT
|
||||
return node != null ? node.key : null;
|
||||
#else
|
||||
return node != null ? node.key : defaultMaxNotFound;
|
||||
#endif
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE ceiling(KEY_TYPE e) {
|
||||
Entry KEY_GENERIC_TYPE node = findCeilingNode(e);
|
||||
#if TYPE_OBJECT
|
||||
return node != null ? node.key : null;
|
||||
#else
|
||||
return node != null ? node.key : defaultMaxNotFound;
|
||||
#endif
|
||||
}
|
||||
|
||||
protected Entry KEY_GENERIC_TYPE findNode(KEY_TYPE o) {
|
||||
Entry KEY_GENERIC_TYPE node = tree;
|
||||
int compare;
|
||||
while(node != null) {
|
||||
if((compare = compare(o, node.key)) == 0) return node;
|
||||
if(compare < 0) node = node.left;
|
||||
else node = node.right;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
protected Entry KEY_GENERIC_TYPE findLowerNode(KEY_TYPE e) {
|
||||
Entry KEY_GENERIC_TYPE entry = tree;
|
||||
while(entry != null) {
|
||||
if(compare(e, entry.key) > 0) {
|
||||
if(entry.right != null) entry = entry.right;
|
||||
else return entry;
|
||||
}
|
||||
else {
|
||||
if(entry.left != null) entry = entry.left;
|
||||
else {
|
||||
Entry KEY_GENERIC_TYPE parent = entry.parent;
|
||||
while(parent != null && parent.left == entry) {
|
||||
entry = parent;
|
||||
parent = parent.parent;
|
||||
}
|
||||
return parent;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
protected Entry KEY_GENERIC_TYPE findFloorNode(KEY_TYPE e) {
|
||||
Entry KEY_GENERIC_TYPE entry = tree;
|
||||
int compare;
|
||||
while(entry != null) {
|
||||
if((compare = compare(e, entry.key)) > 0) {
|
||||
if(entry.right == null) break;
|
||||
entry = entry.right;
|
||||
continue;
|
||||
}
|
||||
else if(compare < 0) {
|
||||
if(entry.left != null) entry = entry.left;
|
||||
else {
|
||||
Entry KEY_GENERIC_TYPE parent = entry.parent;
|
||||
while(parent != null && parent.left == entry) {
|
||||
entry = parent;
|
||||
parent = parent.parent;
|
||||
}
|
||||
return parent;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return entry;
|
||||
}
|
||||
|
||||
protected Entry KEY_GENERIC_TYPE findCeilingNode(KEY_TYPE e) {
|
||||
Entry KEY_GENERIC_TYPE entry = tree;
|
||||
while(entry != null) {
|
||||
if(compare(e, entry.key) < 0) {
|
||||
if(entry.left != null) entry = entry.left;
|
||||
else return entry;
|
||||
}
|
||||
else {
|
||||
if(entry.right != null) entry = entry.right;
|
||||
else {
|
||||
Entry KEY_GENERIC_TYPE parent = entry.parent;
|
||||
while(parent != null && parent.right == entry) {
|
||||
entry = parent;
|
||||
parent = parent.parent;
|
||||
}
|
||||
return parent;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
protected Entry KEY_GENERIC_TYPE findHigherNode(KEY_TYPE e) {
|
||||
Entry KEY_GENERIC_TYPE entry = tree;
|
||||
int compare;
|
||||
while(entry != null) {
|
||||
if((compare = compare(e, entry.key)) < 0) {
|
||||
if(entry.left == null) break;
|
||||
entry = entry.left;
|
||||
continue;
|
||||
}
|
||||
else if(compare < 0) {
|
||||
if(entry.right != null) entry = entry.right;
|
||||
else {
|
||||
Entry KEY_GENERIC_TYPE parent = entry.parent;
|
||||
while(parent != null && parent.right == entry) {
|
||||
entry = parent;
|
||||
parent = parent.parent;
|
||||
}
|
||||
return parent;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return entry;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public boolean contains(KEY_TYPE e) {
|
||||
return findNode(e) != null;
|
||||
}
|
||||
|
||||
#else
|
||||
@Override
|
||||
public boolean contains(Object e) {
|
||||
return findNode((T)e) != null;
|
||||
}
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public KEY_TYPE FIRST_KEY() {
|
||||
if(tree == null) throw new NoSuchElementException();
|
||||
return first.key;
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE LAST_KEY() {
|
||||
if(tree == null) throw new NoSuchElementException();
|
||||
return last.key;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public boolean remove(KEY_TYPE o) {
|
||||
if(tree == null) return false;
|
||||
Entry KEY_GENERIC_TYPE entry = findNode(o);
|
||||
if(entry != null) {
|
||||
removeNode(entry);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
#else
|
||||
@Override
|
||||
public boolean remove(Object o) {
|
||||
if(tree == null) return false;
|
||||
Entry KEY_GENERIC_TYPE entry = findNode((T)o);
|
||||
if(entry != null) {
|
||||
removeNode(entry);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public KEY_TYPE POLL_FIRST_KEY() {
|
||||
if(tree == null) throw new NoSuchElementException();
|
||||
KEY_TYPE value = first.key;
|
||||
removeNode(first);
|
||||
return value;
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE POLL_LAST_KEY() {
|
||||
if(tree == null) throw new NoSuchElementException();
|
||||
KEY_TYPE value = last.key;
|
||||
removeNode(last);
|
||||
return value;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() { return size; }
|
||||
|
||||
@Override
|
||||
public COMPARATOR KEY_GENERIC_TYPE comparator() { return comparator; }
|
||||
|
||||
@Override
|
||||
public BI_ITERATOR KEY_GENERIC_TYPE iterator() { return new SetIterator(false); }
|
||||
|
||||
@Override
|
||||
public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
|
||||
Entry KEY_GENERIC_TYPE entry = findNode(fromElement);
|
||||
return entry == null ? null : new SetIterator(entry);
|
||||
}
|
||||
|
||||
@Override
|
||||
public BI_ITERATOR KEY_GENERIC_TYPE descendingIterator() { return new SetIterator(true); }
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) {
|
||||
return new AscendingSubSetBRACES(this, false, fromElement, fromInclusive, false, toElement, toInclusive);
|
||||
}
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement, boolean inclusive) {
|
||||
return new AscendingSubSetBRACES(this, true, EMPTY_VALUE, true, false, toElement, inclusive);
|
||||
}
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement, boolean inclusive) {
|
||||
return new AscendingSubSetBRACES(this, false, fromElement, inclusive, true, EMPTY_VALUE, true);
|
||||
}
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE descendingSet() {
|
||||
return new DescendingSubSetBRACES(this, true, EMPTY_VALUE, true, true, EMPTY_VALUE, true);
|
||||
}
|
||||
|
||||
protected void removeNode(Entry KEY_GENERIC_TYPE entry) {
|
||||
size--;
|
||||
if(entry.needsSuccessor()) {
|
||||
Entry KEY_GENERIC_TYPE successor = entry.next();
|
||||
entry.key = successor.key;
|
||||
entry = successor;
|
||||
}
|
||||
Entry KEY_GENERIC_TYPE replacement = entry.left != null ? entry.left : entry.right;
|
||||
if(replacement != null) {
|
||||
if(entry.replace(replacement)) tree = replacement;
|
||||
if(entry == first) first = replacement;
|
||||
if(entry == last) last = entry.right != null ? entry.right : replacement;
|
||||
entry.left = entry.right = entry.parent = null;
|
||||
fixAfterDeletion(replacement);
|
||||
}
|
||||
else if(entry.parent == null) tree = first = last = null;
|
||||
else {
|
||||
fixAfterDeletion(entry);
|
||||
entry.replace(null);
|
||||
if(entry.parent != null) {
|
||||
Entry KEY_GENERIC_TYPE parent = entry.parent;
|
||||
if(entry == first) first = parent.left != null ? parent.left : parent;
|
||||
if(entry == last) last = entry.right != null ? parent.right : parent;
|
||||
}
|
||||
entry.parent = null;
|
||||
}
|
||||
}
|
||||
|
||||
protected int compare(KEY_TYPE k, KEY_TYPE v) { return comparator != null ? comparator.compare(k, v) : COMPARE_TO_KEY(k, v);}
|
||||
|
||||
/** From CLR */
|
||||
protected void rotateLeft(Entry KEY_GENERIC_TYPE entry) {
|
||||
if(entry != null) {
|
||||
Entry KEY_GENERIC_TYPE right = entry.right;
|
||||
entry.right = right.left;
|
||||
if(right.left != null) right.left.parent = entry;
|
||||
right.parent = entry.parent;
|
||||
if(entry.parent == null) tree = right;
|
||||
else if(entry.parent.left == entry) entry.parent.left = right;
|
||||
else entry.parent.right = right;
|
||||
right.left = entry;
|
||||
entry.parent = right;
|
||||
}
|
||||
}
|
||||
|
||||
/** From CLR */
|
||||
protected void rotateRight(Entry KEY_GENERIC_TYPE entry) {
|
||||
if(entry != null) {
|
||||
Entry KEY_GENERIC_TYPE left = entry.left;
|
||||
entry.left = left.right;
|
||||
if(left.right != null) left.right.parent = entry;
|
||||
left.parent = entry.parent;
|
||||
if(entry.parent == null) tree = left;
|
||||
else if(entry.parent.right == entry) entry.parent.right = left;
|
||||
else entry.parent.left = left;
|
||||
left.right = entry;
|
||||
entry.parent = left;
|
||||
}
|
||||
}
|
||||
|
||||
/** From CLR */
|
||||
protected void fixAfterInsertion(Entry KEY_GENERIC_TYPE entry) {
|
||||
while(entry != null) {
|
||||
entry.updateHeight();
|
||||
int balance = entry.getBalance();
|
||||
if(balance > 1) {
|
||||
int compare = entry.left.getBalance();
|
||||
if(compare > 0) rotateRight(entry);
|
||||
else if(compare < 0) {
|
||||
rotateLeft(entry.left);
|
||||
rotateRight(entry);
|
||||
}
|
||||
}
|
||||
else if(balance < -1) {
|
||||
int compare = entry.right.getBalance();
|
||||
if(compare < 0) rotateLeft(entry);
|
||||
else if(compare > 0) {
|
||||
rotateRight(entry.right);
|
||||
rotateLeft(entry);
|
||||
}
|
||||
}
|
||||
entry = entry.parent;
|
||||
}
|
||||
}
|
||||
|
||||
/** From CLR */
|
||||
protected void fixAfterDeletion(Entry KEY_GENERIC_TYPE entry) {
|
||||
if(entry != null) {
|
||||
entry.updateHeight();
|
||||
int balance = entry.getBalance();
|
||||
if(balance > 1) {
|
||||
int subBalance = entry.left.getBalance();
|
||||
if(subBalance >= 0) rotateRight(entry);
|
||||
else {
|
||||
rotateLeft(entry.left);
|
||||
rotateRight(entry);
|
||||
}
|
||||
}
|
||||
else if(balance < -1)
|
||||
{
|
||||
int subBalance = entry.right.getBalance();
|
||||
if(subBalance <= 0) rotateLeft(entry);
|
||||
else {
|
||||
rotateRight(entry.right);
|
||||
rotateLeft(entry);
|
||||
}
|
||||
}
|
||||
entry = entry.parent;
|
||||
}
|
||||
}
|
||||
|
||||
private static class AscendingSubSet KEY_GENERIC_TYPE extends SubSet KEY_GENERIC_TYPE
|
||||
{
|
||||
AscendingSubSet(AVL_TREE_SET KEY_GENERIC_TYPE set, boolean fromStart, KEY_TYPE start, boolean loInclusive, boolean toEnd, KEY_TYPE end, boolean hiInclusive) {
|
||||
super(set, fromStart, start, loInclusive, toEnd, end, hiInclusive);
|
||||
}
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) {
|
||||
if(!inRange(fromElement, fromInclusive)) throw new IllegalArgumentException("fromElement is not in Range");
|
||||
if(!inRange(toElement, toInclusive)) throw new IllegalArgumentException("toElement is not in Range");
|
||||
return new AscendingSubSetBRACES(set, false, fromElement, fromInclusive, false, toElement, toInclusive);
|
||||
}
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement, boolean inclusive) {
|
||||
if(!inRange(toElement, inclusive)) throw new IllegalArgumentException("toElement is not in Range");
|
||||
return new AscendingSubSetBRACES(set, fromStart, start, loInclusive, false, toElement, inclusive);
|
||||
}
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement, boolean inclusive) {
|
||||
if(!inRange(fromElement, inclusive)) throw new IllegalArgumentException("fromElement is not in Range");
|
||||
return new AscendingSubSetBRACES(set, false, fromElement, inclusive, toEnd, end, hiInclusive);
|
||||
}
|
||||
|
||||
@Override
|
||||
public BI_ITERATOR KEY_GENERIC_TYPE iterator() { return new SubSetIterator(findLowest()); }
|
||||
|
||||
@Override
|
||||
public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
|
||||
Entry KEY_GENERIC_TYPE entry = set.findNode(fromElement);
|
||||
return entry == null || !inClosedRange(fromElement) ? null : new SubSetIterator(entry);
|
||||
}
|
||||
|
||||
@Override
|
||||
public BI_ITERATOR KEY_GENERIC_TYPE descendingIterator() { return new SubSetIterator(findHighest()); }
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE descendingSet() {
|
||||
return new DescendingSubSetBRACES(set, fromStart, start, loInclusive, toEnd, end, hiInclusive);
|
||||
}
|
||||
}
|
||||
|
||||
private static class DescendingSubSet KEY_GENERIC_TYPE extends SubSet KEY_GENERIC_TYPE
|
||||
{
|
||||
COMPARATOR KEY_GENERIC_TYPE comparator;
|
||||
DescendingSubSet(AVL_TREE_SET KEY_GENERIC_TYPE set, boolean fromStart, KEY_TYPE start, boolean loInclusive, boolean toEnd, KEY_TYPE end, boolean hiInclusive) {
|
||||
super(set, fromStart, start, loInclusive, toEnd, end, hiInclusive);
|
||||
comparator = set.comparator().reversed();
|
||||
}
|
||||
|
||||
@Override
|
||||
public COMPARATOR KEY_GENERIC_TYPE comparator() { return comparator; }
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, boolean fromInclusive, KEY_TYPE toElement, boolean toInclusive) {
|
||||
if(!inRange(fromElement, fromInclusive)) throw new IllegalArgumentException("fromElement is not in Range");
|
||||
if(!inRange(toElement, toInclusive)) throw new IllegalArgumentException("toElement is not in Range");
|
||||
return new DescendingSubSetBRACES(set, false, toElement, toInclusive, false, fromElement, fromInclusive);
|
||||
}
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement, boolean inclusive) {
|
||||
if(!inRange(toElement, inclusive)) throw new IllegalArgumentException("toElement is not in Range");
|
||||
return new DescendingSubSetBRACES(set, false, toElement, inclusive, toEnd, end, hiInclusive);
|
||||
}
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement, boolean inclusive) {
|
||||
if(!inRange(fromElement, inclusive)) throw new IllegalArgumentException("fromElement is not in Range");
|
||||
return new DescendingSubSetBRACES(set, fromStart, start, loInclusive, false, fromElement, inclusive);
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE FIRST_KEY() { return super.LAST_KEY(); }
|
||||
|
||||
@Override
|
||||
public KEY_TYPE POLL_FIRST_KEY() { return super.POLL_LAST_KEY(); }
|
||||
|
||||
@Override
|
||||
public KEY_TYPE LAST_KEY() { return super.FIRST_KEY(); }
|
||||
|
||||
@Override
|
||||
public KEY_TYPE POLL_LAST_KEY() { return super.POLL_FIRST_KEY(); }
|
||||
|
||||
@Override
|
||||
public KEY_TYPE lower(KEY_TYPE e) { return super.higher(e); }
|
||||
|
||||
@Override
|
||||
public KEY_TYPE floor(KEY_TYPE e) { return super.ceiling(e); }
|
||||
|
||||
@Override
|
||||
public KEY_TYPE ceiling(KEY_TYPE e) { return super.floor(e); }
|
||||
|
||||
@Override
|
||||
public KEY_TYPE higher(KEY_TYPE e) { return super.lower(e); }
|
||||
|
||||
@Override
|
||||
public BI_ITERATOR KEY_GENERIC_TYPE iterator() { return new DescendingSubIterator(findHighest()); }
|
||||
|
||||
@Override
|
||||
public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
|
||||
Entry KEY_GENERIC_TYPE entry = set.findNode(fromElement);
|
||||
return entry == null || !inClosedRange(fromElement) ? null : new DescendingSubIterator(entry);
|
||||
}
|
||||
|
||||
@Override
|
||||
public BI_ITERATOR KEY_GENERIC_TYPE descendingIterator() { return new DescendingSubIterator(findLowest()); }
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE descendingSet() {
|
||||
return new AscendingSubSetBRACES(set, fromStart, start, loInclusive, toEnd, end, hiInclusive);
|
||||
}
|
||||
|
||||
private class DescendingSubIterator extends SubSetIterator
|
||||
{
|
||||
public DescendingSubIterator(Entry KEY_GENERIC_TYPE entry) {
|
||||
super(entry);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void updateNext() {
|
||||
next = current.previous();
|
||||
if(!toEnd && next != null && bottomReached(next)) next = null;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void updatePrevious() {
|
||||
previous = current.next();
|
||||
if(!fromStart && previous != null && topReached(previous)) previous = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static abstract class SubSet KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements NAVIGABLE_SET KEY_GENERIC_TYPE
|
||||
{
|
||||
AVL_TREE_SET KEY_GENERIC_TYPE set;
|
||||
KEY_TYPE start;
|
||||
KEY_TYPE end;
|
||||
boolean fromStart;
|
||||
boolean toEnd;
|
||||
boolean loInclusive;
|
||||
boolean hiInclusive;
|
||||
|
||||
SubSet(AVL_TREE_SET KEY_GENERIC_TYPE set, boolean fromStart, KEY_TYPE start, boolean loInclusive, boolean toEnd, KEY_TYPE end, boolean hiInclusive) {
|
||||
this.set = set;
|
||||
this.start = start;
|
||||
this.end = end;
|
||||
this.fromStart = fromStart;
|
||||
this.toEnd = toEnd;
|
||||
this.loInclusive = loInclusive;
|
||||
this.hiInclusive = hiInclusive;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public void setDefaultMaxValue(KEY_TYPE value) { throw new UnsupportedOperationException(); }
|
||||
|
||||
@Override
|
||||
public KEY_TYPE getDefaultMaxValue() { return set.getDefaultMaxValue(); }
|
||||
|
||||
@Override
|
||||
public void setDefaultMinValue(KEY_TYPE value) { throw new UnsupportedOperationException(); }
|
||||
|
||||
@Override
|
||||
public KEY_TYPE getDefaultMinValue() { return set.getDefaultMinValue(); }
|
||||
|
||||
#else
|
||||
public KEY_TYPE getDefaultMaxValue() { return null; }
|
||||
|
||||
public KEY_TYPE getDefaultMinValue() { return null; }
|
||||
|
||||
#endif
|
||||
boolean tooLow(KEY_TYPE key) { return !fromStart && (loInclusive ? set.compare(key, start) < 0 : set.compare(key, start) <= 0); }
|
||||
boolean tooHigh(KEY_TYPE key) { return !toEnd && (hiInclusive ? set.compare(key, end) > 0 : set.compare(key, end) >= 0); }
|
||||
boolean inRange(KEY_TYPE key) { return !tooLow(key) && !tooHigh(key); }
|
||||
boolean inClosedRange(KEY_TYPE key) { return (fromStart || set.compare(key, start) >= 0) && (toEnd || set.compare(end, key) >= 0); }
|
||||
boolean inRange(KEY_TYPE key, boolean inclusive) { return inclusive ? inRange(key) : inClosedRange(key); }
|
||||
|
||||
@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 set.comparator(); }
|
||||
|
||||
@Override
|
||||
public KEY_TYPE FIRST_KEY() {
|
||||
Entry KEY_GENERIC_TYPE entry = findLowest();
|
||||
return entry == null ? getDefaultMaxValue() : entry.key;
|
||||
}
|
||||
|
||||
protected Entry KEY_GENERIC_TYPE findLowest() {
|
||||
if(fromStart) return set.first;
|
||||
Entry KEY_GENERIC_TYPE entry = loInclusive ? set.findCeilingNode(start) : set.findHigherNode(start);
|
||||
return entry == null || tooHigh(entry.key) ? null : entry;
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE POLL_FIRST_KEY() {
|
||||
if(fromStart) return set.POLL_FIRST_KEY();
|
||||
Entry KEY_GENERIC_TYPE entry = loInclusive ? set.findCeilingNode(start) : set.findHigherNode(start);
|
||||
if(entry != null && !tooHigh(entry.key)) {
|
||||
KEY_TYPE value = entry.key;
|
||||
set.removeNode(entry);
|
||||
return value;
|
||||
}
|
||||
return getDefaultMaxValue();
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE LAST_KEY() {
|
||||
Entry KEY_GENERIC_TYPE entry = findHighest();
|
||||
return entry == null ? getDefaultMinValue() : entry.key;
|
||||
}
|
||||
|
||||
protected Entry KEY_GENERIC_TYPE findHighest() {
|
||||
if(toEnd) return set.last;
|
||||
Entry KEY_GENERIC_TYPE entry = hiInclusive ? set.findFloorNode(end) : set.findLowerNode(end);
|
||||
return entry == null || tooLow(entry.key) ? null : entry;
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE POLL_LAST_KEY() {
|
||||
if(toEnd) return set.POLL_LAST_KEY();
|
||||
Entry KEY_GENERIC_TYPE entry = hiInclusive ? set.findFloorNode(end) : set.findLowerNode(end);
|
||||
if(entry != null && !tooLow(entry.key)) {
|
||||
KEY_TYPE value = entry.key;
|
||||
set.removeNode(entry);
|
||||
return value;
|
||||
}
|
||||
return getDefaultMinValue();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean add(KEY_TYPE o) {
|
||||
if(!inRange(o)) throw new IllegalArgumentException("Key is out of range");
|
||||
return set.add(o);
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public boolean contains(KEY_TYPE e) {
|
||||
return inRange(e) && set.contains(e);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean remove(KEY_TYPE o) {
|
||||
return inRange(o) && set.remove(o);
|
||||
}
|
||||
|
||||
#else
|
||||
@Override
|
||||
public boolean contains(Object e) {
|
||||
return inRange((T)e) && set.contains((T)e);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean remove(Object o) {
|
||||
return inRange((T)o) && set.remove((T)o);
|
||||
}
|
||||
|
||||
#endif
|
||||
@Override
|
||||
public KEY_TYPE lower(KEY_TYPE e) {
|
||||
if(tooHigh(e)) {
|
||||
Entry KEY_GENERIC_TYPE entry = findHighest();
|
||||
return entry == null ? getDefaultMinValue() : entry.key;
|
||||
}
|
||||
Entry KEY_GENERIC_TYPE entry = set.findLowerNode(e);
|
||||
return entry == null || tooHigh(entry.key) ? getDefaultMaxValue() : entry.key;
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE floor(KEY_TYPE e) {
|
||||
if(tooHigh(e)) {
|
||||
Entry KEY_GENERIC_TYPE entry = findHighest();
|
||||
return entry == null ? getDefaultMinValue() : entry.key;
|
||||
}
|
||||
Entry KEY_GENERIC_TYPE entry = set.findFloorNode(e);
|
||||
return entry == null || tooHigh(entry.key) ? getDefaultMaxValue() : entry.key;
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE ceiling(KEY_TYPE e) {
|
||||
if(tooLow(e)) {
|
||||
Entry KEY_GENERIC_TYPE entry = findLowest();
|
||||
return entry == null ? getDefaultMaxValue() : entry.key;
|
||||
}
|
||||
Entry KEY_GENERIC_TYPE entry = set.findCeilingNode(e);
|
||||
return entry == null || tooLow(entry.key) ? getDefaultMinValue() : entry.key;
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE higher(KEY_TYPE e) {
|
||||
if(tooLow(e)) {
|
||||
Entry KEY_GENERIC_TYPE entry = findLowest();
|
||||
return entry == null ? getDefaultMaxValue() : entry.key;
|
||||
}
|
||||
Entry KEY_GENERIC_TYPE entry = set.findHigherNode(e);
|
||||
return entry == null || tooLow(entry.key) ? getDefaultMinValue() : entry.key;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() {
|
||||
return fromStart && toEnd ? set.size() : iterator().skip(Integer.MAX_VALUE);
|
||||
}
|
||||
|
||||
class SubSetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE
|
||||
{
|
||||
Entry KEY_GENERIC_TYPE previous;
|
||||
Entry KEY_GENERIC_TYPE next;
|
||||
Entry KEY_GENERIC_TYPE current;
|
||||
int index = 0;
|
||||
|
||||
public SubSetIterator(Entry KEY_GENERIC_TYPE entry) {
|
||||
next = entry;
|
||||
previous = entry == null ? null : entry.previous();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return next != null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasPrevious() {
|
||||
return previous != null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int nextIndex() {
|
||||
return index;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int previousIndex() {
|
||||
return index - 1;
|
||||
}
|
||||
|
||||
boolean topReached(Entry KEY_GENERIC_TYPE entry) {
|
||||
return hiInclusive ? set.compare(entry.key, end) >= 0 : set.compare(entry.key, end) > 0;
|
||||
}
|
||||
|
||||
boolean bottomReached(Entry KEY_GENERIC_TYPE entry) {
|
||||
return loInclusive ? set.compare(entry.key, start) <= 0 : set.compare(entry.key, start) < 0;
|
||||
}
|
||||
|
||||
protected void updateNext() {
|
||||
next = current.next();
|
||||
if(!toEnd && next != null && topReached(next)) next = null;
|
||||
}
|
||||
|
||||
protected void updatePrevious() {
|
||||
previous = current.previous();
|
||||
if(!fromStart && previous != null && bottomReached(previous)) previous = null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE NEXT() {
|
||||
if(!hasNext()) throw new NoSuchElementException();
|
||||
current = previous = next;
|
||||
updateNext();
|
||||
index++;
|
||||
return current.key;
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE PREVIOUS() {
|
||||
if(!hasPrevious()) throw new NoSuchElementException();
|
||||
current = next = previous;
|
||||
updatePrevious();
|
||||
index--;
|
||||
return current.key;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove() {
|
||||
if(current == null) throw new IllegalStateException();
|
||||
if(current == previous) index--;
|
||||
updateNext();
|
||||
updatePrevious();
|
||||
set.removeNode(current);
|
||||
current = null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void set(KEY_TYPE e){ throw new UnsupportedOperationException(); }
|
||||
|
||||
@Override
|
||||
public void add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
|
||||
}
|
||||
}
|
||||
|
||||
private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE
|
||||
{
|
||||
Entry KEY_GENERIC_TYPE previous;
|
||||
Entry KEY_GENERIC_TYPE next;
|
||||
Entry KEY_GENERIC_TYPE current;
|
||||
int index = 0;
|
||||
|
||||
public SetIterator(boolean descending) {
|
||||
if(descending) previous = last;
|
||||
else next = first;
|
||||
}
|
||||
|
||||
public SetIterator(Entry KEY_GENERIC_TYPE entry) {
|
||||
next = entry;
|
||||
previous = entry.previous();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return next != null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasPrevious() {
|
||||
return previous != null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int nextIndex() {
|
||||
return index;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int previousIndex() {
|
||||
return index - 1;
|
||||
}
|
||||
|
||||
protected void updateNext() {
|
||||
next = current.next();
|
||||
}
|
||||
|
||||
protected void updatePrevious() {
|
||||
previous = current.previous();
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE NEXT() {
|
||||
if(!hasNext()) throw new NoSuchElementException();
|
||||
current = previous = next;
|
||||
updateNext();
|
||||
index++;
|
||||
return current.key;
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE PREVIOUS() {
|
||||
if(!hasPrevious()) throw new NoSuchElementException();
|
||||
current = next = previous;
|
||||
updatePrevious();
|
||||
index--;
|
||||
return current.key;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove() {
|
||||
if(current == null) throw new IllegalStateException();
|
||||
if(current == previous) index--;
|
||||
updateNext();
|
||||
updatePrevious();
|
||||
removeNode(current);
|
||||
current = null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void set(KEY_TYPE e){ throw new UnsupportedOperationException(); }
|
||||
|
||||
@Override
|
||||
public void add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
|
||||
}
|
||||
|
||||
private static final class Entry KEY_GENERIC_TYPE
|
||||
{
|
||||
KEY_TYPE key;
|
||||
int state;
|
||||
Entry KEY_GENERIC_TYPE parent;
|
||||
Entry KEY_GENERIC_TYPE left;
|
||||
Entry KEY_GENERIC_TYPE right;
|
||||
|
||||
Entry(KEY_TYPE key, Entry KEY_GENERIC_TYPE parent) {
|
||||
this.key = key;
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
int getHeight() { return state; }
|
||||
|
||||
void updateHeight() { state = (1 + Math.max(left == null ? 0 : left.getHeight(), right == null ? 0 : right.getHeight())); }
|
||||
|
||||
int getBalance() { return (left == null ? 0 : left.getHeight()) - (right == null ? 0 : right.getBalance()); }
|
||||
|
||||
boolean needsSuccessor() { return left != null && right != null; }
|
||||
|
||||
boolean replace(Entry KEY_GENERIC_TYPE entry) {
|
||||
if(entry != null) entry.parent = parent;
|
||||
if(parent != null) {
|
||||
if(parent.left == this) parent.left = entry;
|
||||
else parent.right = entry;
|
||||
}
|
||||
return parent == null;
|
||||
}
|
||||
|
||||
Entry KEY_GENERIC_TYPE next() {
|
||||
if(right != null) {
|
||||
Entry KEY_GENERIC_TYPE parent = right;
|
||||
while(parent.left != null) parent = parent.left;
|
||||
return parent;
|
||||
}
|
||||
Entry KEY_GENERIC_TYPE parent = this.parent;
|
||||
Entry KEY_GENERIC_TYPE control = this;
|
||||
while(parent != null && control == parent.right) {
|
||||
control = parent;
|
||||
parent = parent.parent;
|
||||
}
|
||||
return parent;
|
||||
}
|
||||
|
||||
Entry KEY_GENERIC_TYPE previous() {
|
||||
if(left != null) {
|
||||
Entry KEY_GENERIC_TYPE parent = left;
|
||||
while(parent.right != null) parent = parent.right;
|
||||
return parent;
|
||||
}
|
||||
Entry KEY_GENERIC_TYPE parent = this.parent;
|
||||
Entry KEY_GENERIC_TYPE control = this;
|
||||
while(parent != null && control == parent.left) {
|
||||
control = parent;
|
||||
parent = parent.parent;
|
||||
}
|
||||
return parent;
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -3,6 +3,7 @@ package speiger.src.collections.PACKAGE.utils;
|
|||
import java.util.Iterator;
|
||||
import speiger.src.collections.PACKAGE.collections.ITERATOR;
|
||||
import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
|
||||
import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
|
||||
|
||||
/**
|
||||
* A Helper class for Iterators
|
||||
|
|
@ -32,6 +33,10 @@ public class ITERATORS
|
|||
return iterator instanceof UnmodifiableIterator ? iterator : new UnmodifiableIteratorBRACES(iterator);
|
||||
}
|
||||
|
||||
public static GENERIC_BRACES BI_ITERATOR KEY_GENERIC_TYPE unmodifiable(BI_ITERATOR KEY_GENERIC_TYPE iterator) {
|
||||
return iterator instanceof UnmodifiableBiIterator ? iterator : new UnmodifiableBiIteratorBRACES(iterator);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a Immutable ListIterator instance based on the instance given.
|
||||
* @param l that should be made immutable/unmodifyable
|
||||
|
|
@ -262,6 +267,35 @@ public class ITERATORS
|
|||
public void add(KEY_TYPE e) { throw new UnsupportedOperationException(); }
|
||||
}
|
||||
|
||||
private static class UnmodifiableBiIterator KEY_GENERIC_TYPE implements BI_ITERATOR KEY_GENERIC_TYPE
|
||||
{
|
||||
BI_ITERATOR KEY_GENERIC_TYPE iter;
|
||||
|
||||
UnmodifiableBiIterator(BI_ITERATOR KEY_GENERIC_TYPE iter) {
|
||||
this.iter = iter;
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE NEXT() {
|
||||
return iter.NEXT();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return iter.hasNext();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasPrevious() {
|
||||
return iter.hasPrevious();
|
||||
}
|
||||
|
||||
@Override
|
||||
public KEY_TYPE PREVIOUS() {
|
||||
return iter.PREVIOUS();
|
||||
}
|
||||
}
|
||||
|
||||
private static class UnmodifiableIterator KEY_GENERIC_TYPE implements ITERATOR KEY_GENERIC_TYPE
|
||||
{
|
||||
ITERATOR KEY_GENERIC_TYPE iterator;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,362 @@
|
|||
package speiger.src.collections.PACKAGE.utils;
|
||||
|
||||
#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.sets.NAVIGABLE_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;
|
||||
|
||||
public class SETS
|
||||
{
|
||||
public static final SET NO_GENERIC_TYPE EMPTY = new EmptySetBRACES();
|
||||
|
||||
public static GENERIC_BRACES SET KEY_GENERIC_TYPE empty() {
|
||||
#if TYPE_OBJECT
|
||||
return (SET<KEY_TYPE>)EMPTY;
|
||||
#else
|
||||
return EMPTY;
|
||||
#endif
|
||||
}
|
||||
|
||||
public static GENERIC_BRACES SET KEY_GENERIC_TYPE synchronizedSet(SET KEY_GENERIC_TYPE s) {
|
||||
return s instanceof SynchronizedSet ? s : new SynchronizedSetBRACES(s);
|
||||
}
|
||||
|
||||
public static GENERIC_BRACES SET KEY_GENERIC_TYPE synchronizedSet(SET KEY_GENERIC_TYPE s, Object mutex) {
|
||||
return s instanceof SynchronizedSet ? s : new SynchronizedSetBRACES(s, mutex);
|
||||
}
|
||||
|
||||
public static GENERIC_BRACES SORTED_SET KEY_GENERIC_TYPE synchronizedSet(SORTED_SET KEY_GENERIC_TYPE s) {
|
||||
return s instanceof SynchronizedSortedSet ? s : new SynchronizedSortedSetBRACES(s);
|
||||
}
|
||||
|
||||
public static GENERIC_BRACES SORTED_SET KEY_GENERIC_TYPE synchronizedSet(SORTED_SET KEY_GENERIC_TYPE s, Object mutex) {
|
||||
return s instanceof SynchronizedSortedSet ? s : new SynchronizedSortedSetBRACES(s, mutex);
|
||||
}
|
||||
|
||||
public static GENERIC_BRACES NAVIGABLE_SET KEY_GENERIC_TYPE synchronizedSet(NAVIGABLE_SET KEY_GENERIC_TYPE s) {
|
||||
return s instanceof SynchronizedNavigableSet ? s : new SynchronizedNavigableSetBRACES(s);
|
||||
}
|
||||
|
||||
public static GENERIC_BRACES NAVIGABLE_SET KEY_GENERIC_TYPE synchronizedSet(NAVIGABLE_SET KEY_GENERIC_TYPE s, Object mutex) {
|
||||
return s instanceof SynchronizedNavigableSet ? s : new SynchronizedNavigableSetBRACES(s, mutex);
|
||||
}
|
||||
|
||||
public static GENERIC_BRACES SET KEY_GENERIC_TYPE unmodifiable(SET KEY_GENERIC_TYPE s) {
|
||||
return s instanceof SynchronizedSet ? s : new SynchronizedSetBRACES(s);
|
||||
}
|
||||
|
||||
public static GENERIC_BRACES SORTED_SET KEY_GENERIC_TYPE unmodifiable(SORTED_SET KEY_GENERIC_TYPE s) {
|
||||
return s instanceof SynchronizedSortedSet ? s : new SynchronizedSortedSetBRACES(s);
|
||||
}
|
||||
|
||||
public static GENERIC_BRACES NAVIGABLE_SET KEY_GENERIC_TYPE unmodifiable(NAVIGABLE_SET KEY_GENERIC_TYPE s) {
|
||||
return s instanceof UnmodifiableNavigableSet ? s : new UnmodifiableNavigableSetBRACES(s);
|
||||
}
|
||||
|
||||
public 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
|
||||
}
|
||||
|
||||
public static class UnmodifiableNavigableSet KEY_GENERIC_TYPE extends UnmodifiableSortedSet KEY_GENERIC_TYPE implements NAVIGABLE_SET KEY_GENERIC_TYPE
|
||||
{
|
||||
NAVIGABLE_SET KEY_GENERIC_TYPE n;
|
||||
|
||||
public 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)); }
|
||||
|
||||
}
|
||||
|
||||
public static class UnmodifiableSortedSet KEY_GENERIC_TYPE extends UnmodifiableSet KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE
|
||||
{
|
||||
SORTED_SET KEY_GENERIC_TYPE s;
|
||||
public 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(); }
|
||||
}
|
||||
|
||||
public static class UnmodifiableSet KEY_GENERIC_TYPE extends UnmodifiableCollection KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
|
||||
{
|
||||
SET KEY_GENERIC_TYPE s;
|
||||
|
||||
public UnmodifiableSet(SET KEY_GENERIC_TYPE c)
|
||||
{
|
||||
super(c);
|
||||
s = c;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public boolean remove(KEY_TYPE o) { throw new UnsupportedOperationException(); }
|
||||
#endif
|
||||
}
|
||||
|
||||
public static class SynchronizedNavigableSet KEY_GENERIC_TYPE extends SynchronizedSortedSet KEY_GENERIC_TYPE implements NAVIGABLE_SET KEY_GENERIC_TYPE
|
||||
{
|
||||
NAVIGABLE_SET KEY_GENERIC_TYPE n;
|
||||
|
||||
public SynchronizedNavigableSet(NAVIGABLE_SET KEY_GENERIC_TYPE c) {
|
||||
super(c);
|
||||
n = c;
|
||||
}
|
||||
|
||||
public 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 synchronizedSet(n.subSet(fromElement, fromInclusive, toElement, toInclusive), mutex); } }
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement, boolean inclusive) { synchronized(mutex) { return synchronizedSet(n.headSet(toElement, inclusive), mutex); } }
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement, boolean inclusive) { synchronized(mutex) { return synchronizedSet(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 synchronizedSet(n.descendingSet(), mutex); } }
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE subSet(KEY_TYPE fromElement, KEY_TYPE toElement) { synchronized(mutex) { return synchronizedSet(n.subSet(fromElement, toElement), mutex); } }
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { synchronized(mutex) { return synchronizedSet(n.headSet(toElement), mutex); } }
|
||||
|
||||
@Override
|
||||
public NAVIGABLE_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { synchronized(mutex) { return synchronizedSet(n.tailSet(fromElement), mutex); } }
|
||||
}
|
||||
|
||||
public static class SynchronizedSortedSet KEY_GENERIC_TYPE extends SynchronizedSet KEY_GENERIC_TYPE implements SORTED_SET KEY_GENERIC_TYPE
|
||||
{
|
||||
SORTED_SET KEY_GENERIC_TYPE s;
|
||||
|
||||
public SynchronizedSortedSet(SORTED_SET KEY_GENERIC_TYPE c) {
|
||||
super(c);
|
||||
s = c;
|
||||
}
|
||||
|
||||
public 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 synchronizedSet(s.subSet(fromElement, toElement), mutex); } }
|
||||
|
||||
@Override
|
||||
public SORTED_SET KEY_GENERIC_TYPE headSet(KEY_TYPE toElement) { synchronized(mutex) { return synchronizedSet(s.headSet(toElement), mutex); } }
|
||||
|
||||
@Override
|
||||
public SORTED_SET KEY_GENERIC_TYPE tailSet(KEY_TYPE fromElement) { synchronized(mutex) { return synchronizedSet(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(); } }
|
||||
}
|
||||
|
||||
public static class SynchronizedSet KEY_GENERIC_TYPE extends SynchronizedCollection KEY_GENERIC_TYPE implements SET KEY_GENERIC_TYPE
|
||||
{
|
||||
SET KEY_GENERIC_TYPE s;
|
||||
|
||||
public SynchronizedSet(SET KEY_GENERIC_TYPE c) {
|
||||
super(c);
|
||||
s = c;
|
||||
}
|
||||
|
||||
public SynchronizedSet(SET KEY_GENERIC_TYPE c, Object mutex) {
|
||||
super(c, mutex);
|
||||
s = c;
|
||||
}
|
||||
|
||||
#if !TYPE_OBJECT
|
||||
@Override
|
||||
public boolean remove(KEY_TYPE o) { synchronized(mutex) { return s.remove(o); } }
|
||||
#endif
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue