KitsuneAlex/Primitive-Collections
1
0
Fork 0
forked from Speiger/Primitive-Collections
Code Issues Pull Requests Projects Releases Wiki Activity

Synced first part of the next update

Browse Source
This commit is contained in:
Speiger
2026-05-11 00:20:50 +02:00
parent 2a2d9e8d95
commit 29ddc55947
794 changed files with 65099 additions and 16962 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/builder/resources/speiger/assets/collections/templates/maps/abstracts/AbstractMap.template
+137 -2
View File
@@ -14,6 +14,15 @@ import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
#endif
import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
#if ORDERED_MAP_FEATURE
import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
#if !TYPE_OBJECT
import speiger.src.collections.objects.sets.AbstractObjectSet;
import speiger.src.collections.objects.sets.ObjectOrderedSet;
#endif
#endif
import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
import speiger.src.collections.PACKAGE.sets.SET;
#if MAPS_FEATURE
@@ -42,7 +51,7 @@ import speiger.src.collections.utils.SanityChecks;
*/
public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CLASS_TYPE, CLASS_VALUE_TYPE> implements MAP KEY_VALUE_GENERIC_TYPE
{
protected VALUE_TYPE defaultReturnValue = EMPTY_VALUE;
protected VALUE_TYPE defaultReturnValue = INVALID_VALUE;
@Override
public VALUE_TYPE getDefaultReturnValue() {
@@ -119,7 +128,7 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
public void putAll(CLASS_TYPE[] keys, CLASS_VALUE_TYPE[] values, int offset, int size) {
SanityChecks.checkArrayCapacity(keys.length, offset, size);
SanityChecks.checkArrayCapacity(values.length, offset, size);
for(int i = 0;i<size;i++) put(keys[i], values[i]);
for(int i = 0;i<size;i++) put(OBJ_TO_KEY(keys[i]), OBJ_TO_VALUE(values[i]));
}
#endif
@@ -543,6 +552,132 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
return hash;
}
public static class REVERSED_ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE implements ORDERED_MAP KEY_VALUE_GENERIC_TYPE {
ORDERED_MAP KEY_VALUE_GENERIC_TYPE map;
public REVERSED_ORDERED_MAP(ORDERED_MAP KEY_VALUE_GENERIC_TYPE map) {
this.map = map;
}
@Override
public ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE setDefaultReturnValue(VALUE_TYPE v) {
map.setDefaultReturnValue(v);
return this;
}
@Override
public VALUE_TYPE getDefaultReturnValue() { return map.getDefaultReturnValue(); }
@Override
public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
@Override
public VALUE_TYPE put(KEY_TYPE key, VALUE_TYPE value) { return map.put(key, value); }
@Override
public VALUE_TYPE putIfAbsent(KEY_TYPE key, VALUE_TYPE value) { return map.putIfAbsent(key, value); }
#if VALUE_PRIMITIVES
@Override
public VALUE_TYPE addTo(KEY_TYPE key, VALUE_TYPE value) { return map.addTo(key, value); }
@Override
public VALUE_TYPE subFrom(KEY_TYPE key, VALUE_TYPE value) { return map.subFrom(key, value); }
#endif
@Override
public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) { return map.REMOVE_VALUE(key); }
#if !TYPE_OBJECT || !VALUE_OBJECT
@Override
public boolean remove(KEY_TYPE key, VALUE_TYPE value) { return map.remove(key, value); }
#endif
@Override
public VALUE_TYPE REMOVE_VALUEOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.REMOVE_VALUEOrDefault(key, defaultValue); }
@Override
#if TYPE_OBJECT
public boolean containsKey(Object key) { return map.containsKey(key); }
#else
public boolean containsKey(KEY_TYPE key) { return map.containsKey(key); }
#endif
@Override
#if VALUE_OBJECT
public boolean containsValue(Object value) { return map.containsValue(value); }
#else
public boolean containsValue(VALUE_TYPE value) { return map.containsValue(value); }
#endif
@Override
public boolean replace(KEY_TYPE key, VALUE_TYPE oldValue, VALUE_TYPE newValue) { return map.replace(key, oldValue, newValue); }
@Override
public VALUE_TYPE replace(KEY_TYPE key, VALUE_TYPE value) { return map.replace(key, value); }
@Override
public void REPLACE_VALUES(MAP KEY_VALUE_GENERIC_TYPE m) { map.REPLACE_VALUES(m); }
@Override
public void REPLACE_VALUES(UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { map.REPLACE_VALUES(mappingFunction); }
@Override
public VALUE_TYPE COMPUTE(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { return map.COMPUTE(key, mappingFunction); }
@Override
public VALUE_TYPE COMPUTE_IF_ABSENT(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) { return map.COMPUTE_IF_ABSENT(key, mappingFunction); }
@Override
public VALUE_TYPE SUPPLY_IF_ABSENT(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) { return map.SUPPLY_IF_ABSENT(key, valueProvider); }
@Override
public VALUE_TYPE COMPUTE_IF_PRESENT(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { return map.COMPUTE_IF_PRESENT(key, mappingFunction); }
#if !VALUE_OBJECT
@Override
public VALUE_TYPE COMPUTENonDefault(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { return map.COMPUTENonDefault(key, mappingFunction); }
@Override
public VALUE_TYPE COMPUTE_IF_ABSENTNonDefault(KEY_TYPE key, FUNCTION KEY_VALUE_GENERIC_TYPE mappingFunction) { return map.COMPUTE_IF_ABSENTNonDefault(key, mappingFunction); }
@Override
public VALUE_TYPE SUPPLY_IF_ABSENTNonDefault(KEY_TYPE key, VALUE_SUPPLIER VALUE_GENERIC_TYPE valueProvider) { return map.SUPPLY_IF_ABSENTNonDefault(key, valueProvider); }
@Override
public VALUE_TYPE COMPUTE_IF_PRESENTNonDefault(KEY_TYPE key, UNARY_OPERATOR KEY_VALUE_GENERIC_TYPE mappingFunction) { return map.COMPUTE_IF_PRESENTNonDefault(key, mappingFunction); }
#endif
@Override
public VALUE_TYPE MERGE(KEY_TYPE key, VALUE_TYPE value, VALUE_UNARY_OPERATOR VALUE_VALUE_GENERIC_TYPE mappingFunction) { return map.MERGE(key, value, mappingFunction); }
#if !TYPE_OBJECT || !VALUE_OBJECT
@Override
public VALUE_TYPE getOrDefault(KEY_TYPE key, VALUE_TYPE defaultValue) { return map.getOrDefault(key, defaultValue); }
#endif
@Override
public VALUE_TYPE GET_VALUE(KEY_TYPE key) { return map.GET_VALUE(key); }
@Override
public VALUE_TYPE putAndMoveToFirst(KEY_TYPE key, VALUE_TYPE value) { return map.putAndMoveToLast(key, value); }
@Override
public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { return map.putAndMoveToFirst(key, value); }
@Override
public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) { return map.putLast(key, value); }
@Override
public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) { return map.putFirst(key, value); }
@Override
public boolean moveToFirst(KEY_TYPE key) { return map.moveToLast(key); }
@Override
public boolean moveToLast(KEY_TYPE key) { return map.moveToFirst(key); }
@Override
public VALUE_TYPE getAndMoveToFirst(KEY_TYPE key) { return map.getAndMoveToLast(key); }
@Override
public VALUE_TYPE getAndMoveToLast(KEY_TYPE key) { return map.getAndMoveToFirst(key); }
@Override
public KEY_TYPE FIRST_ENTRY_KEY() { return map.LAST_ENTRY_KEY(); }
@Override
public KEY_TYPE POLL_FIRST_ENTRY_KEY() { return map.POLL_LAST_ENTRY_KEY(); }
@Override
public KEY_TYPE LAST_ENTRY_KEY() { return map.FIRST_ENTRY_KEY(); }
@Override
public KEY_TYPE POLL_LAST_ENTRY_KEY() { return map.POLL_FIRST_ENTRY_KEY(); }
@Override
public VALUE_TYPE FIRST_ENTRY_VALUE() { return map.LAST_ENTRY_VALUE(); }
@Override
public VALUE_TYPE LAST_ENTRY_VALUE() { return map.FIRST_ENTRY_VALUE(); }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { return map.lastEntry(); }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { return map.firstEntry(); }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { return map.pollLastEntry(); }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { return map.pollFirstEntry(); }
@Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.ENTRY_SET()); }
@Override
public ORDERED_SET KEY_GENERIC_TYPE keySet() { return new ABSTRACT_SET.REVERSED_ORDERED_SETBRACES(map.keySet()); }
@Override
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() { return map.values().reversed(); }
@Override
public ORDERED_MAP KEY_VALUE_GENERIC_TYPE reversed() { return map; }
}
/**
* A Simple Type Specific Entry class to reduce boxing/unboxing
* @Type(T)
src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/LinkedOpenCustomHashMap.template
+176 -50
View File
@@ -40,7 +40,7 @@ import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
import speiger.src.collections.PACKAGE.utils.STRATEGY;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
#if !SAME_TYPE
import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR;
@@ -295,6 +295,54 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
return getDefaultReturnValue();
}
@Override
public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) {
if(strategy.equals(key, EMPTY_KEY_VALUE)) {
if(containsNull) return values[nullIndex];
values[nullIndex] = value;
containsNull = true;
onNodeAdded(nullIndex);
moveToFirstIndex(nullIndex);
}
else {
int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) {
if(strategy.equals(keys[pos], key)) return values[pos];
pos = ++pos & mask;
}
keys[pos] = key;
values[pos] = value;
onNodeAdded(pos);
moveToFirstIndex(pos);
}
if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
return getDefaultReturnValue();
}
@Override
public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) {
if(strategy.equals(key, EMPTY_KEY_VALUE)) {
if(containsNull) return values[nullIndex];
values[nullIndex] = value;
containsNull = true;
onNodeAdded(nullIndex);
moveToLastIndex(nullIndex);
}
else {
int pos = HashUtil.mix(strategy.hashCode(key)) & mask;
while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) {
if(strategy.equals(keys[pos], key)) return values[pos];
pos = ++pos & mask;
}
keys[pos] = key;
values[pos] = value;
onNodeAdded(pos);
moveToLastIndex(pos);
}
if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
return getDefaultReturnValue();
}
@Override
public boolean moveToFirst(KEY_TYPE key) {
if(isEmpty() || strategy.equals(FIRST_ENTRY_KEY(), key)) return false;
@@ -430,6 +478,52 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
return values[lastIndex];
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() {
if(size == 0) throw new NoSuchElementException();
return new BasicEntryKV_BRACES(keys[firstIndex], values[firstIndex]);
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() {
if(size == 0) throw new NoSuchElementException();
return new BasicEntryKV_BRACES(keys[lastIndex], values[lastIndex]);
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() {
if(size == 0) throw new NoSuchElementException();
int pos = firstIndex;
onNodeRemoved(pos);
BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]);
size--;
if(strategy.equals(result.ENTRY_KEY(), EMPTY_KEY_VALUE)) {
containsNull = false;
keys[nullIndex] = EMPTY_KEY_VALUE;
values[nullIndex] = EMPTY_VALUE;
}
else shiftKeys(pos);
if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2);
return result;
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() {
if(size == 0) throw new NoSuchElementException();
int pos = lastIndex;
onNodeRemoved(pos);
BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]);
size--;
if(strategy.equals(result.ENTRY_KEY(), EMPTY_KEY_VALUE)) {
containsNull = false;
keys[nullIndex] = EMPTY_KEY_VALUE;
values[nullIndex] = EMPTY_VALUE;
}
else shiftKeys(pos);
if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2);
return result;
}
@Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
if(entrySet == null) entrySet = new MapEntrySet();
@@ -443,9 +537,9 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
}
@Override
public VALUE_COLLECTION VALUE_GENERIC_TYPE values() {
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
if(valuesC == null) valuesC = new Values();
return valuesC;
return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)valuesC;
}
@Override
@@ -630,24 +724,24 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE first() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() {
return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE last() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() {
return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() {
BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
POLL_FIRST_ENTRY_KEY();
return entry;
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() {
BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
POLL_LAST_ENTRY_KEY();
return entry;
@@ -655,7 +749,12 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
return new EntryIterator();
return new EntryIterator(true);
}
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> reverseIterator() {
return new EntryIterator(false);
}
@Override
@@ -665,7 +764,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
return new FastEntryIterator();
return new FastEntryIterator(true);
}
@Override
@@ -919,7 +1018,12 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
return new KeyIterator();
return new KeyIterator(true);
}
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return new KeyIterator(false);
}
@Override
@@ -941,22 +1045,22 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
}
@Override
public KEY_TYPE FIRST_KEY() {
public KEY_TYPE GET_FIRST_KEY() {
return FIRST_ENTRY_KEY();
}
@Override
public KEY_TYPE POLL_FIRST_KEY() {
public KEY_TYPE REMOVE_FIRST_KEY() {
return POLL_FIRST_ENTRY_KEY();
}
@Override
public KEY_TYPE LAST_KEY() {
public KEY_TYPE GET_LAST_KEY() {
return LAST_ENTRY_KEY();
}
@Override
public KEY_TYPE POLL_LAST_KEY() {
public KEY_TYPE REMOVE_LAST_KEY() {
return POLL_LAST_ENTRY_KEY();
}
@@ -1100,39 +1204,47 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
}
}
private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE {
#if VALUE_OBJECT
@Override
@Deprecated
public boolean contains(Object e) {
return containsValue(e);
}
public boolean contains(Object e) { return containsValue(e); }
#else
@Override
public boolean contains(VALUE_TYPE e) {
return containsValue(e);
}
public boolean contains(VALUE_TYPE e) { return containsValue(e); }
#endif
@Override
public boolean add(VALUE_TYPE o) {
throw new UnsupportedOperationException();
}
public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
@Override
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() {
return new ValueIterator();
}
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
@Override
public int size() {
return LINKED_CUSTOM_HASH_MAP.this.size();
}
public int size() { return LINKED_CUSTOM_HASH_MAP.this.size(); }
@Override
public void clear() {
LINKED_CUSTOM_HASH_MAP.this.clear();
public void clear() { LINKED_CUSTOM_HASH_MAP.this.clear(); }
@Override
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); }
private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() {
return new ValueIterator(false);
}
@Override
public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
@Override
public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
@Override
public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); }
@Override
public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() {
VALUE_TYPE result = FIRST_ENTRY_VALUE();
POLL_FIRST_ENTRY_KEY();
return result;
}
@Override
public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); }
@Override
public VALUE_TYPE VALUE_REMOVE_LAST_KEY() {
VALUE_TYPE result = LAST_ENTRY_VALUE();
POLL_LAST_ENTRY_KEY();
return result;
}
@Override
@@ -1278,7 +1390,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry = new MapEntry();
public FastEntryIterator() {}
public FastEntryIterator(boolean start) { super(start); }
public FastEntryIterator(KEY_TYPE from) {
super(from);
}
@@ -1305,7 +1417,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry;
public EntryIterator() {}
public EntryIterator(boolean start) { super(start); }
public EntryIterator(KEY_TYPE from) {
super(from);
}
@@ -1335,7 +1447,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
public KeyIterator() {}
public KeyIterator(boolean start) { super(start); }
public KeyIterator(KEY_TYPE from) {
super(from);
}
@@ -1357,7 +1469,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
}
private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
public ValueIterator() {}
public ValueIterator(boolean start) { super(start); }
@Override
public VALUE_TYPE VALUE_PREVIOUS() {
@@ -1378,16 +1490,20 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
}
private class MapIterator {
boolean forward;
int previous = -1;
int next = -1;
int current = -1;
int index = 0;
MapIterator() {
next = firstIndex;
MapIterator(boolean start) {
this.forward = start;
if(start) next = firstIndex;
else previous = lastIndex;
}
MapIterator(KEY_TYPE from) {
this.forward = true;
if(strategy.equals(from, EMPTY_KEY_VALUE)) {
if(containsNull) {
next = (int) links[nullIndex];
@@ -1415,11 +1531,11 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
}
public boolean hasNext() {
return next != -1;
return (forward ? next : previous) != -1;
}
public boolean hasPrevious() {
return previous != -1;
return (forward ? previous : next) != -1;
}
public int nextIndex() {
@@ -1479,20 +1595,30 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
public int previousEntry() {
if(!hasPrevious()) throw new NoSuchElementException();
current = previous;
previous = (int)(links[current] >> 32);
next = current;
if(forward) moveBackwards();
else moveForwards();
if(index >= 0) index--;
return current;
}
public int nextEntry() {
if(!hasNext()) throw new NoSuchElementException();
if(forward) moveForwards();
else moveBackwards();
if(index >= 0) index++;
return current;
}
private void moveBackwards() {
current = previous;
previous = (int)(links[current] >> 32);
next = current;
}
private void moveForwards() {
current = next;
next = (int)(links[current]);
previous = current;
if(index >= 0) index++;
return current;
}
private void ensureIndexKnown() {
src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/LinkedOpenHashMap.template
+175 -49
View File
@@ -39,7 +39,7 @@ import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
#if !SAME_TYPE
import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR;
@@ -272,6 +272,54 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
return getDefaultReturnValue();
}
@Override
public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) {
if(KEY_EQUALS_NULL(key)) {
if(containsNull) return values[nullIndex];
values[nullIndex] = value;
containsNull = true;
onNodeAdded(nullIndex);
moveToFirstIndex(nullIndex);
}
else {
int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
while(KEY_EQUALS_NULL(key)) {
if(KEY_EQUALS(keys[pos], key)) return values[pos];
pos = ++pos & mask;
}
keys[pos] = key;
values[pos] = value;
onNodeAdded(pos);
moveToFirstIndex(pos);
}
if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
return getDefaultReturnValue();
}
@Override
public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) {
if(KEY_EQUALS_NULL(key)) {
if(containsNull) return values[nullIndex];
values[nullIndex] = value;
containsNull = true;
onNodeAdded(nullIndex);
moveToLastIndex(nullIndex);
}
else {
int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask;
while(KEY_EQUALS_NULL(key)) {
if(KEY_EQUALS(keys[pos], key)) return values[pos];
pos = ++pos & mask;
}
keys[pos] = key;
values[pos] = value;
onNodeAdded(pos);
moveToLastIndex(pos);
}
if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor));
return getDefaultReturnValue();
}
@Override
public boolean moveToFirst(KEY_TYPE key) {
if(isEmpty() || KEY_EQUALS(FIRST_ENTRY_KEY(), key)) return false;
@@ -434,6 +482,52 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
return values[lastIndex];
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() {
if(size == 0) throw new NoSuchElementException();
return new BasicEntryKV_BRACES(keys[firstIndex], values[firstIndex]);
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() {
if(size == 0) throw new NoSuchElementException();
return new BasicEntryKV_BRACES(keys[lastIndex], values[lastIndex]);
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() {
if(size == 0) throw new NoSuchElementException();
int pos = firstIndex;
onNodeRemoved(pos);
BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]);
size--;
if(KEY_EQUALS_NULL(result.ENTRY_KEY())) {
containsNull = false;
keys[nullIndex] = EMPTY_KEY_VALUE;
values[nullIndex] = EMPTY_VALUE;
}
else shiftKeys(pos);
if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2);
return result;
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() {
if(size == 0) throw new NoSuchElementException();
int pos = lastIndex;
onNodeRemoved(pos);
BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]);
size--;
if(KEY_EQUALS_NULL(result.ENTRY_KEY())) {
containsNull = false;
keys[nullIndex] = EMPTY_KEY_VALUE;
values[nullIndex] = EMPTY_VALUE;
}
else shiftKeys(pos);
if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2);
return result;
}
@Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
if(entrySet == null) entrySet = new MapEntrySet();
@@ -447,9 +541,9 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
}
@Override
public VALUE_COLLECTION VALUE_GENERIC_TYPE values() {
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
if(valuesC == null) valuesC = new Values();
return valuesC;
return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)valuesC;
}
@Override
@@ -634,24 +728,24 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE first() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() {
return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE last() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() {
return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() {
BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
POLL_FIRST_ENTRY_KEY();
return entry;
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() {
BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
POLL_LAST_ENTRY_KEY();
return entry;
@@ -659,7 +753,12 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
return new EntryIterator();
return new EntryIterator(true);
}
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> reverseIterator() {
return new EntryIterator(false);
}
@Override
@@ -669,7 +768,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
return new FastEntryIterator();
return new FastEntryIterator(true);
}
@Override
@@ -918,7 +1017,12 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
return new KeyIterator();
return new KeyIterator(true);
}
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return new KeyIterator(false);
}
@Override
@@ -940,22 +1044,22 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
}
@Override
public KEY_TYPE FIRST_KEY() {
public KEY_TYPE GET_FIRST_KEY() {
return FIRST_ENTRY_KEY();
}
@Override
public KEY_TYPE POLL_FIRST_KEY() {
public KEY_TYPE REMOVE_FIRST_KEY() {
return POLL_FIRST_ENTRY_KEY();
}
@Override
public KEY_TYPE LAST_KEY() {
public KEY_TYPE GET_LAST_KEY() {
return LAST_ENTRY_KEY();
}
@Override
public KEY_TYPE POLL_LAST_KEY() {
public KEY_TYPE REMOVE_LAST_KEY() {
return POLL_LAST_ENTRY_KEY();
}
@@ -1099,41 +1203,50 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
}
}
private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE {
#if VALUE_OBJECT
@Override
@Deprecated
public boolean contains(Object e) {
return containsValue(e);
}
public boolean contains(Object e) { return containsValue(e); }
#else
@Override
public boolean contains(VALUE_TYPE e) {
return containsValue(e);
}
public boolean contains(VALUE_TYPE e) { return containsValue(e); }
#endif
@Override
public boolean add(VALUE_TYPE o) {
throw new UnsupportedOperationException();
}
public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
@Override
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() {
return new ValueIterator();
}
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
@Override
public int size() {
return LINKED_HASH_MAP.this.size();
}
public int size() { return LINKED_HASH_MAP.this.size(); }
@Override
public void clear() {
LINKED_HASH_MAP.this.clear();
public void clear() { LINKED_HASH_MAP.this.clear(); }
@Override
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); }
private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() {
return new ValueIterator(false);
}
@Override
public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
@Override
public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
@Override
public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); }
@Override
public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() {
VALUE_TYPE result = FIRST_ENTRY_VALUE();
POLL_FIRST_ENTRY_KEY();
return result;
}
@Override
public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); }
@Override
public VALUE_TYPE VALUE_REMOVE_LAST_KEY() {
VALUE_TYPE result = LAST_ENTRY_VALUE();
POLL_LAST_ENTRY_KEY();
return result;
}
@Override
public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) {
Objects.requireNonNull(action);
@@ -1278,7 +1391,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry = new MapEntry();
public FastEntryIterator() {}
public FastEntryIterator(boolean start) { super(start); }
public FastEntryIterator(KEY_TYPE from) {
super(from);
}
@@ -1305,7 +1418,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry;
public EntryIterator() {}
public EntryIterator(boolean start) { super(start); }
public EntryIterator(KEY_TYPE from) {
super(from);
}
@@ -1335,7 +1448,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
public KeyIterator() {}
public KeyIterator(boolean start) { super(start); }
public KeyIterator(KEY_TYPE from) {
super(from);
}
@@ -1357,7 +1470,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
}
private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
public ValueIterator() {}
public ValueIterator(boolean start) { super(start); }
@Override
public VALUE_TYPE VALUE_PREVIOUS() {
@@ -1377,13 +1490,16 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
}
private class MapIterator {
boolean forward;
int previous = -1;
int next = -1;
int current = -1;
int index = 0;
MapIterator() {
next = firstIndex;
MapIterator(boolean start) {
this.forward = start;
if(start) next = firstIndex;
else previous = lastIndex;
}
MapIterator(KEY_TYPE from) {
@@ -1414,11 +1530,11 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
}
public boolean hasNext() {
return next != -1;
return (forward ? next : previous) != -1;
}
public boolean hasPrevious() {
return previous != -1;
return (forward ? previous : next) != -1;
}
public int nextIndex() {
@@ -1478,20 +1594,30 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
public int previousEntry() {
if(!hasPrevious()) throw new NoSuchElementException();
current = previous;
previous = (int)(links[current] >> 32);
next = current;
if(forward) moveBackwards();
else moveForwards();
if(index >= 0) index--;
return current;
}
public int nextEntry() {
if(!hasNext()) throw new NoSuchElementException();
if(forward) moveForwards();
else moveBackwards();
if(index >= 0) index++;
return current;
}
private void moveBackwards() {
current = previous;
previous = (int)(links[current] >> 32);
next = current;
}
private void moveForwards() {
current = next;
next = (int)(links[current]);
previous = current;
if(index >= 0) index++;
return current;
}
private void ensureIndexKnown() {
src/builder/resources/speiger/assets/collections/templates/maps/impl/immutable/ImmutableOpenHashMap.template
+95 -48
View File
@@ -65,7 +65,7 @@ import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
#endif
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER;
#if !SAME_TYPE
@@ -119,7 +119,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
/** KeySet cache */
protected transient ORDERED_SET KEY_GENERIC_TYPE keySet;
/** Values cache */
protected transient VALUE_COLLECTION VALUE_GENERIC_TYPE valuesC;
protected transient VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE valuesC;
/** Amount of Elements stored in the HashMap */
protected int size;
@@ -320,6 +320,10 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
@Override
public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
@Override
public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
@Override
public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
@Override
public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
@Override
public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
@@ -441,7 +445,24 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
public VALUE_TYPE LAST_ENTRY_VALUE() {
if(size == 0) throw new NoSuchElementException();
return values[lastIndex];
}
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() {
if(size == 0) throw new NoSuchElementException();
return new BasicEntryKV_BRACES(keys[firstIndex], values[firstIndex]);
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() {
if(size == 0) throw new NoSuchElementException();
return new BasicEntryKV_BRACES(keys[lastIndex], values[lastIndex]);
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { throw new UnsupportedOperationException(); }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { throw new UnsupportedOperationException(); }
@Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
@@ -456,7 +477,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
}
@Override
public VALUE_COLLECTION VALUE_GENERIC_TYPE values() {
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
if(valuesC == null) valuesC = new Values();
return valuesC;
}
@@ -621,24 +642,29 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
public boolean moveToLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE first() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() {
return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE last() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() {
return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() { throw new UnsupportedOperationException(); }
public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() { throw new UnsupportedOperationException(); }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() { throw new UnsupportedOperationException(); }
public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() { throw new UnsupportedOperationException(); }
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
return new EntryIterator();
return new EntryIterator(true);
}
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> reverseIterator() {
return new EntryIterator(false);
}
@Override
@@ -648,7 +674,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
return new FastEntryIterator();
return new FastEntryIterator(true);
}
@Override
@@ -875,7 +901,12 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
return new KeyIterator();
return new KeyIterator(true);
}
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return new KeyIterator(false);
}
@Override
@@ -895,20 +926,20 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
public void clear() { throw new UnsupportedOperationException(); }
@Override
public KEY_TYPE FIRST_KEY() {
public KEY_TYPE GET_FIRST_KEY() {
return FIRST_ENTRY_KEY();
}
@Override
public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); }
public KEY_TYPE REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); }
@Override
public KEY_TYPE LAST_KEY() {
public KEY_TYPE GET_LAST_KEY() {
return LAST_ENTRY_KEY();
}
@Override
public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); }
public KEY_TYPE REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); }
@Override
public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
@@ -1050,39 +1081,42 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
}
}
private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE {
#if VALUE_OBJECT
@Override
@Deprecated
public boolean contains(Object e) {
return containsValue(e);
}
public boolean contains(Object e) { return containsValue(e); }
#else
@Override
public boolean contains(VALUE_TYPE e) {
return containsValue(e);
}
public boolean contains(VALUE_TYPE e) { return containsValue(e); }
#endif
@Override
public boolean add(VALUE_TYPE o) {
throw new UnsupportedOperationException();
}
public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
@Override
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() {
return new ValueIterator();
}
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
@Override
public int size() {
return IMMUTABLE_HASH_MAP.this.size();
}
public int size() { return IMMUTABLE_HASH_MAP.this.size(); }
@Override
public void clear() { throw new UnsupportedOperationException(); }
@Override
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); }
private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() {
return new ValueIterator(false);
}
@Override
public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
@Override
public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
@Override
public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); }
@Override
public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); }
@Override
public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); }
@Override
public VALUE_TYPE VALUE_REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); }
@Override
public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) {
int index = firstIndex;
@@ -1226,7 +1260,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry = new MapEntry();
public FastEntryIterator() {}
public FastEntryIterator(boolean start) { super(start); }
public FastEntryIterator(KEY_TYPE from) {
super(from);
}
@@ -1252,7 +1286,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
public EntryIterator() {}
public EntryIterator(boolean start) { super(start); }
public EntryIterator(KEY_TYPE from) {
super(from);
}
@@ -1279,7 +1313,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
public KeyIterator() {}
public KeyIterator(boolean start) { super(start); }
public KeyIterator(KEY_TYPE from) {
super(from);
}
@@ -1301,7 +1335,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
}
private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
public ValueIterator() {}
public ValueIterator(boolean start) { super(start); }
@Override
public VALUE_TYPE VALUE_PREVIOUS() {
@@ -1322,13 +1356,16 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
}
private class MapIterator {
boolean forward;
int previous = -1;
int next = -1;
int current = -1;
int index = 0;
MapIterator() {
next = firstIndex;
MapIterator(boolean start) {
this.forward = start;
if(start) next = firstIndex;
else previous = lastIndex;
}
MapIterator(KEY_TYPE from) {
@@ -1359,11 +1396,11 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
}
public boolean hasNext() {
return next != -1;
return (forward ? next : previous) != -1;
}
public boolean hasPrevious() {
return previous != -1;
return (forward ? previous : next) != -1;
}
public int nextIndex() {
@@ -1380,20 +1417,30 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
public int previousEntry() {
if(!hasPrevious()) throw new NoSuchElementException();
current = previous;
previous = (int)(links[current] >> 32);
next = current;
if(forward) moveBackwards();
else moveForwards();
if(index >= 0) index--;
return current;
}
public int nextEntry() {
if(!hasNext()) throw new NoSuchElementException();
if(forward) moveForwards();
else moveBackwards();
if(index >= 0) index++;
return current;
}
private void moveBackwards() {
current = previous;
previous = (int)(links[current] >> 32);
next = current;
}
private void moveForwards() {
current = next;
next = (int)(links[current]);
previous = current;
if(index >= 0) index++;
return current;
}
private void ensureIndexKnown() {
src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template
+153 -63
View File
@@ -46,7 +46,7 @@ import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER;
#if !SAME_TYPE
@@ -105,7 +105,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
/** KeySet cache */
protected ORDERED_SET KEY_GENERIC_TYPE keySet;
/** Values cache */
protected VALUE_COLLECTION VALUE_GENERIC_TYPE valuesC;
protected VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE valuesC;
/** EntrySet cache */
protected FastOrderedSet KEY_VALUE_GENERIC_TYPE entrySet;
@@ -275,6 +275,27 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
return lastValue;
}
@Override
public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) {
int index = findIndex(key);
if(index < 0) {
insertIndex(0, key, value);
size++;
return getDefaultReturnValue();
}
return values[index];
}
@Override
public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) {
int index = findIndex(key);
if(index < 0) {
insertIndex(size++, key, value);
return getDefaultReturnValue();
}
return values[index];
}
@Override
public boolean moveToFirst(KEY_TYPE key) {
int index = findIndex(key);
@@ -402,6 +423,34 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
return result;
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() {
if(size == 0) throw new NoSuchElementException();
return new BasicEntryKV_BRACES(keys[0], values[0]);
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() {
if(size == 0) throw new NoSuchElementException();
return new BasicEntryKV_BRACES(keys[size-1], values[size-1]);
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() {
if(size == 0) throw new NoSuchElementException();
BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[0], values[0]);
removeIndex(0);
return result;
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() {
if(size == 0) throw new NoSuchElementException();
BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[size-1], values[size-1]);
removeIndex(size-1);
return result;
}
@Override
public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) {
int index = findIndex(key);
@@ -461,7 +510,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
}
@Override
public VALUE_COLLECTION VALUE_GENERIC_TYPE values() {
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
if(valuesC == null) valuesC = new Values();
return valuesC;
}
@@ -828,24 +877,24 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE first() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() {
return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE last() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() {
return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() {
BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
POLL_FIRST_ENTRY_KEY();
return entry;
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() {
BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
POLL_LAST_ENTRY_KEY();
return entry;
@@ -853,7 +902,12 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
return new EntryIterator();
return new EntryIterator(true);
}
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> reverseIterator() {
return new EntryIterator(false);
}
@Override
@@ -863,7 +917,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
return new FastEntryIterator();
return new FastEntryIterator(true);
}
@Override
@@ -1073,7 +1127,9 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
@Override
public boolean moveToLast(KEY_TYPE o) { return ARRAY_MAP.this.moveToLast(o); }
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { return new KeyIterator(); }
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { return new KeyIterator(true); }
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() { return new KeyIterator(false); }
@Override
public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { return new KeyIterator(fromElement); }
@Override
@@ -1081,13 +1137,13 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
@Override
public void clear() { ARRAY_MAP.this.clear(); }
@Override
public KEY_TYPE FIRST_KEY() { return FIRST_ENTRY_KEY(); }
public KEY_TYPE GET_FIRST_KEY() { return FIRST_ENTRY_KEY(); }
@Override
public KEY_TYPE POLL_FIRST_KEY() { return POLL_FIRST_ENTRY_KEY(); }
public KEY_TYPE REMOVE_FIRST_KEY() { return POLL_FIRST_ENTRY_KEY(); }
@Override
public KEY_TYPE LAST_KEY() { return LAST_ENTRY_KEY(); }
public KEY_TYPE GET_LAST_KEY() { return LAST_ENTRY_KEY(); }
@Override
public KEY_TYPE POLL_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); }
public KEY_TYPE REMOVE_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); }
@Override
public KeySet copy() { throw new UnsupportedOperationException(); }
@@ -1197,40 +1253,49 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
}
}
private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE {
#if VALUE_OBJECT
@Override
public boolean contains(Object e) {
return containsValue(e);
}
public boolean contains(Object e) { return containsValue(e); }
#else
@Override
public boolean contains(VALUE_TYPE e) {
return containsValue(e);
}
public boolean contains(VALUE_TYPE e) { return containsValue(e); }
#endif
@Override
public boolean add(VALUE_TYPE o) {
throw new UnsupportedOperationException();
}
public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
@Override
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() {
return new ValueIterator();
}
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
@Override
public int size() {
return ARRAY_MAP.this.size();
}
public int size() { return ARRAY_MAP.this.size(); }
@Override
public void clear() {
ARRAY_MAP.this.clear();
public void clear() { ARRAY_MAP.this.clear(); }
@Override
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); }
private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() {
return new ValueIterator(false);
}
@Override
public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
@Override
public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
@Override
public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); }
@Override
public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() {
VALUE_TYPE result = FIRST_ENTRY_VALUE();
POLL_FIRST_ENTRY_KEY();
return result;
}
@Override
public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); }
@Override
public VALUE_TYPE VALUE_REMOVE_LAST_KEY() {
VALUE_TYPE result = LAST_ENTRY_VALUE();
POLL_LAST_ENTRY_KEY();
return result;
}
@Override
public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) {
Objects.requireNonNull(action);
@@ -1332,10 +1397,8 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry = new MapEntry();
public FastEntryIterator() {}
public FastEntryIterator(KEY_TYPE from) {
index = findIndex(from);
}
public FastEntryIterator(boolean start) { super(start); }
public FastEntryIterator(KEY_TYPE element) { super(element); }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE next() {
@@ -1358,11 +1421,8 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry = null;
public EntryIterator() {}
public EntryIterator(KEY_TYPE from) {
index = findIndex(from);
if(index == -1) throw new NoSuchElementException();
}
public EntryIterator(boolean start) { super(start); }
public EntryIterator(KEY_TYPE element) { super(element); }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE next() {
@@ -1389,11 +1449,8 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
}
private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
public KeyIterator() {}
public KeyIterator(KEY_TYPE element) {
index = findIndex(element);
if(index == -1) throw new NoSuchElementException();
}
public KeyIterator(boolean start) { super(start); }
public KeyIterator(KEY_TYPE element) { super(element); }
@Override
public KEY_TYPE PREVIOUS() {
@@ -1413,6 +1470,9 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
}
private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
public ValueIterator(boolean start) { super(start); }
public ValueIterator(KEY_TYPE element) { super(element); }
@Override
public VALUE_TYPE VALUE_PREVIOUS() {
return values[previousEntry()];
@@ -1431,23 +1491,37 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
}
private class MapIterator {
boolean forward;
int index;
int lastReturned = -1;
MapIterator(boolean start) {
this.forward = start;
this.index = start ? 0 : size;
}
MapIterator(KEY_TYPE element) {
this.forward = true;
index = findIndex(element);
if(index == -1) throw new NoSuchElementException();
}
public boolean hasNext() {
return index < size;
return forward ? index < size : index > 0;
}
public boolean hasPrevious() {
return index > 0;
return forward ? index > 0 : index < size;
}
public int nextIndex() {
return index;
if(forward) return index;
return size - index;
}
public int previousIndex() {
return index-1;
if(forward) return index-1;
return (size - index)-1;
}
public void remove() {
@@ -1460,26 +1534,42 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
public int previousEntry() {
if(!hasPrevious()) throw new NoSuchElementException();
index--;
return (lastReturned = index);
}
public int nextEntry() {
if(!hasNext()) throw new NoSuchElementException();
if(forward) {
index--;
return (lastReturned = index);
}
lastReturned = index;
return index++;
}
public int nextEntry() {
if(!hasNext()) throw new NoSuchElementException();
if(forward) {
lastReturned = index;
return index++;
}
index--;
return (lastReturned = index);
}
public int skip(int amount) {
if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
return forward ? moveForward(amount) : moveBackwards(amount);
}
public int back(int amount) {
if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
return forward ? moveBackwards(amount) : moveForward(amount);
}
private int moveForward(int amount) {
int steps = Math.min(amount, size() - index);
index += steps;
if(steps > 0) lastReturned = Math.min(index-1, size()-1);
return steps;
}
public int back(int amount) {
if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed");
private int moveBackwards(int amount) {
int steps = Math.min(amount, index);
index -= steps;
if(steps > 0) lastReturned = Math.min(index, size()-1);
src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/LinkedEnumMap.template
+140 -49
View File
@@ -18,7 +18,7 @@ import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR;
#if !VALUE_OBJECT && !SAME_TYPE
import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_CONSUMER;
@@ -216,6 +216,28 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
return getDefaultReturnValue();
}
@Override
public VALUE_TYPE putFirst(T key, VALUE_TYPE value) {
int index = key.ordinal();
if(isSet(index)) return values[index];
set(index);
values[index] = value;
onNodeAdded(index);
moveToFirstIndex(index);
return getDefaultReturnValue();
}
@Override
public VALUE_TYPE putLast(T key, VALUE_TYPE value) {
int index = key.ordinal();
if(isSet(index)) return values[index];
set(index);
values[index] = value;
onNodeAdded(index);
moveToLastIndex(index);
return getDefaultReturnValue();
}
@Override
public boolean moveToFirst(T key) {
int index = key.ordinal();
@@ -312,6 +334,42 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
return values[lastIndex];
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() {
if(size == 0) throw new NoSuchElementException();
return new BasicEntryKV_BRACES(keys[firstIndex], values[firstIndex]);
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() {
if(size == 0) throw new NoSuchElementException();
return new BasicEntryKV_BRACES(keys[lastIndex], values[lastIndex]);
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() {
if(size == 0) throw new NoSuchElementException();
int pos = firstIndex;
firstIndex = (int)links[pos];
if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L;
BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]);
size--;
values[result.ENTRY_KEY().ordinal()] = EMPTY_VALUE;
return result;
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() {
if(size == 0) throw new NoSuchElementException();
int pos = lastIndex;
firstIndex = (int)links[pos];
if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L;
BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]);
size--;
values[result.ENTRY_KEY().ordinal()] = EMPTY_VALUE;
return result;
}
@Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
if(entrySet == null) entrySet = new MapEntrySet();
@@ -325,9 +383,9 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
}
@Override
public VALUE_COLLECTION VALUE_GENERIC_TYPE values() {
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
if(valuesC == null) valuesC = new Values();
return valuesC;
return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)valuesC;
}
@Override
@@ -431,24 +489,24 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE first() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() {
return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE last() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() {
return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() {
BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
POLL_FIRST_ENTRY_KEY();
return entry;
}
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() {
public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() {
BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
POLL_LAST_ENTRY_KEY();
return entry;
@@ -456,7 +514,12 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() {
return new EntryIterator();
return new EntryIterator(true);
}
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> reverseIterator() {
return new EntryIterator(false);
}
@Override
@@ -466,7 +529,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
return new FastEntryIterator();
return new FastEntryIterator(true);
}
@Override
@@ -593,7 +656,12 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
return new KeyIterator();
return new KeyIterator(true);
}
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return new KeyIterator(false);
}
@Override
@@ -614,22 +682,22 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
}
@Override
public T FIRST_KEY() {
public T GET_FIRST_KEY() {
return FIRST_ENTRY_KEY();
}
@Override
public T POLL_FIRST_KEY() {
public T REMOVE_FIRST_KEY() {
return POLL_FIRST_ENTRY_KEY();
}
@Override
public T LAST_KEY() {
public T GET_LAST_KEY() {
return LAST_ENTRY_KEY();
}
@Override
public T POLL_LAST_KEY() {
public T REMOVE_LAST_KEY() {
return POLL_LAST_ENTRY_KEY();
}
@@ -656,41 +724,50 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
#endif
}
private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE {
private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE {
#if VALUE_OBJECT
@Override
@Deprecated
public boolean contains(Object e) {
return containsValue(e);
}
public boolean contains(Object e) { return containsValue(e); }
#else
@Override
public boolean contains(VALUE_TYPE e) {
return containsValue(e);
}
public boolean contains(VALUE_TYPE e) { return containsValue(e); }
#endif
@Override
public boolean add(VALUE_TYPE o) {
throw new UnsupportedOperationException();
}
public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
@Override
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() {
return new ValueIterator();
}
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
@Override
public int size() {
return LINKED_ENUM_MAP.this.size();
}
public int size() { return LINKED_ENUM_MAP.this.size(); }
@Override
public void clear() {
LINKED_ENUM_MAP.this.clear();
public void clear() { LINKED_ENUM_MAP.this.clear(); }
@Override
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); }
private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() {
return new ValueIterator(false);
}
@Override
public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
@Override
public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); }
@Override
public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); }
@Override
public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() {
VALUE_TYPE result = FIRST_ENTRY_VALUE();
POLL_FIRST_ENTRY_KEY();
return result;
}
@Override
public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); }
@Override
public VALUE_TYPE VALUE_REMOVE_LAST_KEY() {
VALUE_TYPE result = LAST_ENTRY_VALUE();
POLL_LAST_ENTRY_KEY();
return result;
}
#if VALUE_OBJECT
@Override
public void forEach(Consumer VALUE_SUPER_GENERIC_TYPE action) {
@@ -715,7 +792,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry = new MapEntry();
public FastEntryIterator() {}
public FastEntryIterator(boolean start) { super(start); }
public FastEntryIterator(T from) {
super(from);
}
@@ -742,7 +819,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry;
public EntryIterator() {}
public EntryIterator(boolean start) { super(start); }
public EntryIterator(T from) {
super(from);
}
@@ -772,7 +849,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
public KeyIterator() {}
public KeyIterator(boolean start) { super(start); }
public KeyIterator(T from) {
super(from);
}
@@ -794,7 +871,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
}
private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
public ValueIterator() {}
public ValueIterator(boolean start) { super(start); }
@Override
public VALUE_TYPE VALUE_PREVIOUS() {
@@ -815,16 +892,20 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
}
private class MapIterator {
boolean forward;
int previous = -1;
int next = -1;
int current = -1;
int index = 0;
MapIterator() {
next = firstIndex;
MapIterator(boolean start) {
this.forward = start;
if(start) next = firstIndex;
else previous = lastIndex;
}
MapIterator(T from) {
this.forward = true;
previous = from.ordinal() - 1;
index = from.ordinal();
next = from.ordinal();
@@ -832,11 +913,11 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
}
public boolean hasNext() {
return next != -1;
return (forward ? next : previous) != -1;
}
public boolean hasPrevious() {
return previous != -1;
return (forward ? previous : next) != -1;
}
public int nextIndex() {
@@ -871,20 +952,30 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
public int previousEntry() {
if(!hasPrevious()) throw new NoSuchElementException();
current = previous;
previous = (int)(links[current] >> 32);
next = current;
if(forward) moveBackwards();
else moveForwards();
if(index >= 0) index--;
return current;
}
public int nextEntry() {
if(!hasNext()) throw new NoSuchElementException();
if(forward) moveForwards();
else moveBackwards();
if(index >= 0) index++;
return current;
}
private void moveBackwards() {
current = previous;
previous = (int)(links[current] >> 32);
next = current;
}
private void moveForwards() {
current = next;
next = (int)(links[current]);
previous = current;
if(index >= 0) index++;
return current;
}
private void ensureIndexKnown() {
src/builder/resources/speiger/assets/collections/templates/maps/interfaces/Map.template
+1 -1
View File
@@ -154,7 +154,7 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map<CLASS_TYPE, CLASS_VALUE_
* @return the last present value or default return value.
*/
public default CLASS_VALUE_TYPE put(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> entry) {
return put(entry.getKey(), entry.getValue());
return put(OBJ_TO_KEY(entry.getKey()), OBJ_TO_VALUE(entry.getValue()));
}
#endif
src/builder/resources/speiger/assets/collections/templates/maps/interfaces/OrderedMap.template
+68
View File
@@ -1,8 +1,15 @@
package speiger.src.collections.PACKAGE.maps.interfaces;
#if JAVA_VERSION>=21
import java.util.Map;
import java.util.SequencedMap;
#endif
#if MAPS_FEATURE
import speiger.src.collections.PACKAGE.utils.maps.MAPS;
#endif
import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
#if !TYPE_OBJECT
import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
#endif
@@ -17,7 +24,11 @@ import speiger.src.collections.objects.sets.ObjectOrderedSet;
* @Type(T)
* @ValueType(V)
*/
#if JAVA_VERSION>=21
public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERIC_TYPE, SequencedMap<CLASS_TYPE, CLASS_VALUE_TYPE>
#else
public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERIC_TYPE
#endif
{
/**
* A customized put method that allows you to insert into the first index.
@@ -37,6 +48,26 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
*/
public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value);
/**
* A alternative to putAndMoveToFirst.
* This method simply puts an entry at the first spot of the Map but only if the entry is missing.
* @param key the key that should be inserted
* @param value the value that should be inserted
* @return the previous present or default return value
* @see java.util.Map#put(Object, Object)
*/
public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value);
/**
* A alternative to putAndMoveToLast.
* This method simply puts an entry at the last spot of the Map but only if the entry is missing.
* @param key the key that should be inserted
* @param value the value that should be inserted
* @return the previous present or default return value
* @see java.util.Map#put(Object, Object)
*/
public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value);
/**
* A specific move method to move a given key/value to the first index.
* @param key that should be moved to the first index
@@ -97,13 +128,34 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
*/
public VALUE_TYPE LAST_ENTRY_VALUE();
@Java21
public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry();
@Java21
public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry();
@Java21
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry();
@Java21
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry();
@Override
public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy();
@Override
public ORDERED_SET KEY_GENERIC_TYPE keySet();
@Override
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values();
@Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET();
@Java21
public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE reversed() { return new ABSTRACT_MAP.REVERSED_ORDERED_MAPKV_BRACES(this); }
#if JAVA_VERSION>=21
@Override
default ORDERED_SET KEY_GENERIC_TYPE sequencedKeySet() { return keySet(); }
@Override
default VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE sequencedValues() { return values(); }
@Override
default ObjectOrderedSet<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> sequencedEntrySet() { return (ObjectOrderedSet<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>)(Object)ENTRY_SET(); }
#endif
#if MAPS_FEATURE
/**
* Creates a Wrapped SortedMap that is Synchronized
@@ -130,6 +182,22 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI
@Override
public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE unmodifiable() { return MAPS.unmodifiable(this); }
#endif
#if JAVA_VERSION>=21
#if !SAME_TYPE || !TYPE_OBJECT
@Override
@Deprecated
public default CLASS_VALUE_TYPE putFirst(CLASS_TYPE k, CLASS_VALUE_TYPE v) {
return putFirst(OBJ_TO_KEY(k), OBJ_TO_VALUE(v));
}
@Override
@Deprecated
public default CLASS_VALUE_TYPE putLast(CLASS_TYPE k, CLASS_VALUE_TYPE v) {
return putLast(OBJ_TO_KEY(k), OBJ_TO_VALUE(v));
}
#endif
#endif
/**
* Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value