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

Started Adding support for JDK21 SequencedCollections.

Browse Source 
Implementation is mostly finished. Just need to iron out bugs.
But at this point i want to push activity.
This commit is contained in:
Speiger 2026-05-09 05:22:35 +02:00
parent 20927a97eb
commit 042460a338
38 changed files with 1584 additions and 378 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.classpath
View File

@ -6,12 +6,6 @@
<attribute name="gradle_used_by_scope" value="main,test"/> <attribute name="gradle_used_by_scope" value="main,test"/>
</attributes> </attributes>
</classpathentry> </classpathentry>
<classpathentry kind="src" output="bin/main" path="src/main/resources">
<attributes>
<attribute name="gradle_scope" value="main"/>
<attribute name="gradle_used_by_scope" value="main,test"/>
</attributes>
</classpathentry>
<classpathentry kind="src" output="bin/test" path="src/test/java"> <classpathentry kind="src" output="bin/test" path="src/test/java">
<attributes> <attributes>
<attribute name="gradle_scope" value="test"/> <attribute name="gradle_scope" value="test"/>
@ -38,7 +32,7 @@
<attribute name="gradle_used_by_scope" value="builder"/> <attribute name="gradle_used_by_scope" value="builder"/>
</attributes> </attributes>
</classpathentry> </classpathentry>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8/"/> <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-21/"/>
<classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/> <classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/>
<classpathentry kind="output" path="bin/default"/> <classpathentry kind="output" path="bin/default"/>
</classpath> </classpath>

27
.project
View File

@ -2,21 +2,22 @@
<projectDescription> <projectDescription>
<name>Primitive-Collections</name> <name>Primitive-Collections</name>
<comment></comment> <comment></comment>
<projects/> <projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures> <natures>
<nature>org.eclipse.jdt.core.javanature</nature> <nature>org.eclipse.jdt.core.javanature</nature>
<nature>org.eclipse.buildship.core.gradleprojectnature</nature> <nature>org.eclipse.buildship.core.gradleprojectnature</nature>
</natures> </natures>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments/>
</buildCommand>
<buildCommand>
<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
<arguments/>
</buildCommand>
</buildSpec>
<linkedResources/>
<filteredResources/>
</projectDescription> </projectDescription>

3
build.gradle
View File

@ -1,7 +1,6 @@
plugins { plugins {
id 'java-library' id 'java-library'
id "jacoco" id "jacoco"
// id "com.vanniktech.maven.publish" version "0.28.0"
} }
tasks.withType(JavaCompile) { tasks.withType(JavaCompile) {
@ -36,6 +35,7 @@ javadoc {
options.tags = [ "implSpec", "note" ] options.tags = [ "implSpec", "note" ]
} }
eclipse { eclipse {
classpath { classpath {
downloadJavadoc = true downloadJavadoc = true
@ -47,6 +47,7 @@ sourceSets {
builder builder
} }
configurations { configurations {
builderCompile.extendsFrom compile builderCompile.extendsFrom compile
} }

2
gradle.properties
View File

@ -1,6 +1,6 @@
org.gradle.jvmargs=-Xmx3G org.gradle.jvmargs=-Xmx3G
maxMemory = 1024m maxMemory = 2048m
testThreads = 4 testThreads = 4
RELEASE_VERSION = 0.9.0 RELEASE_VERSION = 0.9.0

2
gradle/wrapper/gradle-wrapper.properties vendored
View File

@ -1,5 +1,5 @@
distributionBase=GRADLE_USER_HOME distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.1-bin.zip distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
zipStoreBase=GRADLE_USER_HOME zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists zipStorePath=wrapper/dists

4
src/builder/java/speiger/src/builder/modules/CollectionModule.java
View File

@ -41,7 +41,7 @@ public class CollectionModule extends BaseModule
protected void loadBlockades() { protected void loadBlockades() {
if(!MODULE.isEnabled()) { if(!MODULE.isEnabled()) {
addBlockedFiles("Iterable", "Iterables", "Iterator", "Iterators", "BidirectionalIterator", "ListIterator"); addBlockedFiles("Iterable", "Iterables", "Iterator", "Iterators", "BidirectionalIterator", "ListIterator");
addBlockedFiles("Arrays", "Collection", "AbstractCollection", "Collections", "Stack"); addBlockedFiles("Arrays", "Collection", "OrderedCollection", "AbstractCollection", "Collections", "Stack");
} }
if(!SPLIT_ITERATORS.isEnabled()) addBlockedFiles("Splititerator", "Splititerators"); if(!SPLIT_ITERATORS.isEnabled()) addBlockedFiles("Splititerator", "Splititerators");
if(!IARRAY.isEnabled()) addBlockedFiles("IArray"); if(!IARRAY.isEnabled()) addBlockedFiles("IArray");
@ -91,6 +91,7 @@ public class CollectionModule extends BaseModule
{ {
//Abstract Classes //Abstract Classes
addAbstractMapper("ABSTRACT_COLLECTION", "Abstract%sCollection"); addAbstractMapper("ABSTRACT_COLLECTION", "Abstract%sCollection");
addAbstractMapper("REVERSED_ORDERED_COLLECTION", "Reverse%sOrderedCollection");
//Helper Classes //Helper Classes
addClassMapper("ARRAYS", "Arrays"); addClassMapper("ARRAYS", "Arrays");
@ -101,6 +102,7 @@ public class CollectionModule extends BaseModule
//Interfaces //Interfaces
addClassMapper("COLLECTION", "Collection"); addClassMapper("COLLECTION", "Collection");
addClassMapper("ORDERED_COLLECTION", "OrderedCollection");
addClassMapper("ITERABLE", "Iterable"); addClassMapper("ITERABLE", "Iterable");
addClassMapper("SPLIT_ITERATOR", "Splititerator"); addClassMapper("SPLIT_ITERATOR", "Splititerator");
addClassMapper("LIST_ITERATOR", "ListIterator"); addClassMapper("LIST_ITERATOR", "ListIterator");

1
src/builder/java/speiger/src/builder/modules/JavaModule.java
View File

@ -196,6 +196,7 @@ public class JavaModule extends BaseModule
addComment("@Type", "@param <%s> the keyType of elements maintained by this Collection"); addComment("@Type", "@param <%s> the keyType of elements maintained by this Collection");
addValueComment("@ValueArrayType", "@param <%s> the keyType of array that the operation should be applied"); addValueComment("@ValueArrayType", "@param <%s> the keyType of array that the operation should be applied");
addValueComment("@ValueType", "@param <%s> the keyType of elements maintained by this Collection"); addValueComment("@ValueType", "@param <%s> the keyType of elements maintained by this Collection");
addSimpleMapper("@Java21", getVersion() >= 21 ? "@Override" : "");
addAnnontion("@PrimitiveOverride", "@Override"); addAnnontion("@PrimitiveOverride", "@Override");
addSimpleMapper("@PrimitiveDoc", ""); addSimpleMapper("@PrimitiveDoc", "");
addAnnontion("@Primitive", "@Deprecated"); addAnnontion("@Primitive", "@Deprecated");

1
src/builder/java/speiger/src/builder/modules/MapModule.java
View File

@ -253,6 +253,7 @@ public class MapModule extends BaseModule
//Abstract Classes //Abstract Classes
addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2"); addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2");
addAbstractBiMapper("REVERSED_ORDERED_MAP", "Reversed%sOrderedMap", "2");
//Helper Classes //Helper Classes
addBiClassMapper("MAPS", "Maps", "2"); addBiClassMapper("MAPS", "Maps", "2");

1
src/builder/java/speiger/src/builder/modules/SetModule.java
View File

@ -148,6 +148,7 @@ public class SetModule extends BaseModule
//Abstract Classes //Abstract Classes
addAbstractMapper("ABSTRACT_SET", "Abstract%sSet"); addAbstractMapper("ABSTRACT_SET", "Abstract%sSet");
addAbstractMapper("REVERSED_ORDERED_SET", "Reversed%sOrderedSet");
//Helper Classes //Helper Classes
addClassMapper("SETS", "Sets"); addClassMapper("SETS", "Sets");

80
src/builder/resources/speiger/assets/collections/templates/collections/AbstractCollection.template
View File

@ -1,12 +1,18 @@
package speiger.src.collections.PACKAGE.collections; package speiger.src.collections.PACKAGE.collections;
import java.util.Collection; import java.util.Collection;
#if ORDERED_MAP_FEATURE
import java.util.function.Supplier;
#endif
import java.util.Objects; import java.util.Objects;
import java.util.AbstractCollection; import java.util.AbstractCollection;
#if TYPE_OBJECT #if TYPE_OBJECT
import java.util.function.Consumer; import java.util.function.Consumer;
#endif #endif
#if ORDERED_MAP_FEATURE
import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR;
#endif
#if !TYPE_OBJECT #if !TYPE_OBJECT
import speiger.src.collections.PACKAGE.functions.CONSUMER; import speiger.src.collections.PACKAGE.functions.CONSUMER;
import speiger.src.collections.PACKAGE.utils.ITERATORS; import speiger.src.collections.PACKAGE.utils.ITERATORS;
@ -262,5 +268,79 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle
if (a.length > size()) a[size()] = EMPTY_KEY_VALUE; if (a.length > size()) a[size()] = EMPTY_KEY_VALUE;
return a; return a;
} }
#endif
#if ORDERED_MAP_FEATURE
public static class REVERSED_ORDERED_COLLECTION KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION KEY_GENERIC_TYPE implements ORDERED_COLLECTION KEY_GENERIC_TYPE {
ORDERED_COLLECTION KEY_GENERIC_TYPE collection;
Supplier<ITERATOR KEY_GENERIC_TYPE> reverseIterator;
public REVERSED_ORDERED_COLLECTION(ORDERED_COLLECTION KEY_GENERIC_TYPE collection, Supplier<ITERATOR KEY_GENERIC_TYPE> reverseIterator) {
this.collection = collection;
this.reverseIterator = reverseIterator;
}
@Override
public boolean add(KEY_TYPE o) { return collection.add(o); }
@Override
public ORDERED_COLLECTION KEY_GENERIC_TYPE reversed() { return collection; }
@Override
public void addFirst(KEY_TYPE e) { collection.addLast(e); }
@Override
public void addLast(KEY_TYPE e) { collection.addFirst(e); }
@Override
#if !TYPE_OBJECT
public boolean contains(KEY_TYPE e) { return collection.contains(e); }
#else
public boolean contains(Object e) { return collection.contains(e); }
#endif
@Override
#if !TYPE_OBJECT
public boolean REMOVE_KEY(KEY_TYPE e) { return collection.REMOVE_KEY(e); }
#else
public boolean remove(Object e) { return collection.remove(e); }
#endif
@Override
public void clear() { collection.clear(); }
@Override
public KEY_TYPE GET_FIRST_KEY() { return collection.GET_LAST_KEY(); }
@Override
public KEY_TYPE REMOVE_FIRST_KEY() { return collection.REMOVE_LAST_KEY(); }
@Override
public KEY_TYPE GET_LAST_KEY() { return collection.GET_FIRST_KEY(); }
@Override
public KEY_TYPE REMOVE_LAST_KEY() { return collection.REMOVE_FIRST_KEY(); }
@Override
public ITERATOR KEY_GENERIC_TYPE iterator() { return reverseIterator.get(); }
@Override
public int size() { return collection.size(); }
}
public static class ReverseBiIterator KEY_GENERIC_TYPE implements LIST_ITERATOR KEY_GENERIC_TYPE {
LIST_ITERATOR KEY_GENERIC_TYPE it;
public ReverseBiIterator(LIST_ITERATOR KEY_GENERIC_TYPE it) {
this.it = it;
}
@Override
public KEY_TYPE NEXT() { return it.PREVIOUS(); }
@Override
public boolean hasNext() { return it.hasPrevious(); }
@Override
public boolean hasPrevious() { return it.hasNext(); }
@Override
public KEY_TYPE PREVIOUS() { return it.NEXT(); }
@Override
public void remove() { it.remove(); }
@Override
public int nextIndex() { return it.previousIndex(); }
@Override
public int previousIndex() { return it.nextIndex(); }
@Override
public void set(KEY_TYPE e) { it.set(e); }
@Override
public void add(KEY_TYPE e) { it.add(e); }
}
#endif #endif
} }

83
src/builder/resources/speiger/assets/collections/templates/collections/OrderedCollection.template Normal file
View File

@ -0,0 +1,83 @@
package speiger.src.collections.PACKAGE.collections;
#if JAVA_VERSION>=21
import java.util.SequencedCollection;
public interface ORDERED_COLLECTION KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, SequencedCollection<CLASS_TYPE> {
#else
public interface ORDERED_COLLECTION KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE {
#endif
@Java21
ORDERED_COLLECTION KEY_GENERIC_TYPE reversed();
/**
* A method to add an element to the start of a collection
* @param e that should be added at the start.
*/
public void addFirst(KEY_TYPE e);
/**
* A method to add an element to the end of a collection
* @param e that should be added at the end.
*/
public void addLast(KEY_TYPE e);
/**
* A method to get the first element in the collection
* @return first element in the collection
*/
public KEY_TYPE GET_FIRST_KEY();
/**
* A method to get and remove the first element in the collection
* @return first element in the collection
*/
public KEY_TYPE REMOVE_FIRST_KEY();
/**
* A method to get the last element in the collection
* @return last element in the collection
*/
public KEY_TYPE GET_LAST_KEY();
/**
* A method to get and remove the last element in the collection
* @return last element in the collection
*/
public KEY_TYPE REMOVE_LAST_KEY();
#if JAVA_VERSION>=21 && !TYPE_OBJECT
@Override
@Deprecated
default void addFirst(CLASS_TYPE e) {
addFirst(OBJ_TO_KEY(e));
}
@Override
@Deprecated
default void addLast(CLASS_TYPE e) {
addLast(OBJ_TO_KEY(e));
}
@Override
@Deprecated
default CLASS_TYPE getFirst() {
return KEY_TO_OBJ(GET_FIRST_KEY());
}
@Override
@Deprecated
default CLASS_TYPE getLast() {
return KEY_TO_OBJ(GET_LAST_KEY());
}
@Override
@Deprecated
default CLASS_TYPE removeFirst() {
return KEY_TO_OBJ(REMOVE_FIRST_KEY());
}
@Override
@Deprecated
default CLASS_TYPE removeLast() {
return KEY_TO_OBJ(REMOVE_LAST_KEY());
}
#endif
}

6
src/builder/resources/speiger/assets/collections/templates/lists/CopyOnWriteList.template
View File

@ -535,7 +535,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
* @return if the element was found. * @return if the element was found.
*/ */
@Override @Override
@Deprecated @Primitive
public boolean contains(Object o) { public boolean contains(Object o) {
return indexOf(o) != -1; return indexOf(o) != -1;
} }
@ -546,7 +546,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
* @return the index of the element if found. (if not found then -1) * @return the index of the element if found. (if not found then -1)
*/ */
@Override @Override
@Deprecated @Primitive
public int indexOf(Object o) { public int indexOf(Object o) {
KEY_TYPE[] data = this.data; KEY_TYPE[] data = this.data;
#if TYPE_OBJECT #if TYPE_OBJECT
@ -570,7 +570,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER
* @return the last index of the element if found. (if not found then -1) * @return the last index of the element if found. (if not found then -1)
*/ */
@Override @Override
@Deprecated @Primitive
public int lastIndexOf(Object o) { public int lastIndexOf(Object o) {
KEY_TYPE[] data = this.data; KEY_TYPE[] data = this.data;
#if TYPE_OBJECT #if TYPE_OBJECT

74
src/builder/resources/speiger/assets/collections/templates/lists/List.template
View File

@ -15,6 +15,7 @@ import java.util.function.UnaryOperator;
#endif #endif
import speiger.src.collections.PACKAGE.collections.COLLECTION; import speiger.src.collections.PACKAGE.collections.COLLECTION;
import speiger.src.collections.PACKAGE.collections.ORDERED_COLLECTION;
#if SPLIT_ITERATOR_FEATURE #if SPLIT_ITERATOR_FEATURE
import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
#endif #endif
@ -40,7 +41,7 @@ import speiger.src.collections.utils.SanityChecks;
* A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features * A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features
* @Type(T) * @Type(T)
*/ */
public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List<CLASS_TYPE> public interface LIST KEY_GENERIC_TYPE extends ORDERED_COLLECTION KEY_GENERIC_TYPE, List<CLASS_TYPE>
{ {
#if !TYPE_OBJECT #if !TYPE_OBJECT
/** /**
@ -105,6 +106,24 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List
*/ */
public boolean addAll(int index, LIST KEY_GENERIC_TYPE c); public boolean addAll(int index, LIST KEY_GENERIC_TYPE c);
/**
* A method to add an element to the start of a list
* @param e that should be added at the start.
*/
@Override
public default void addFirst(KEY_TYPE e) {
add(0, e);
}
/**
* A method to add an element to the end of a list
* @param e that should be added at the end.
*/
@Override
public default void addLast(KEY_TYPE e) {
add(e);
}
/** /**
* Helper method that returns the first element of a List. * Helper method that returns the first element of a List.
* This function was introduced due to how annoying it is to get/remove the last element of a list. * This function was introduced due to how annoying it is to get/remove the last element of a list.
@ -508,9 +527,56 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List
@Override @Override
@Deprecated @Deprecated
public default boolean add(CLASS_TYPE e) { public default boolean add(CLASS_TYPE e) {
return COLLECTION.super.add(e); return ORDERED_COLLECTION.super.add(e);
}
#if JAVA_VERSION>=21
#if !TYPE_OBJECT
/** {@inheritDoc}
* <p>This default implementation delegates to the corresponding type-specific function.
* @deprecated Please use the corresponding type-specific function instead.
*/
@Override
@Deprecated
default void addFirst(CLASS_TYPE e) {
addFirst(OBJ_TO_KEY(e));
}
/** {@inheritDoc}
* <p>This default implementation delegates to the corresponding type-specific function.
* @deprecated Please use the corresponding type-specific function instead.
*/
@Override
@Deprecated
default void addLast(CLASS_TYPE e) {
addLast(OBJ_TO_KEY(e));
} }
#endif
@Override
@Deprecated
default CLASS_TYPE getFirst() {
return KEY_TO_OBJ(GET_FIRST_KEY());
}
@Override
@Deprecated
default CLASS_TYPE getLast() {
return KEY_TO_OBJ(GET_LAST_KEY());
}
@Override
@Deprecated
default CLASS_TYPE removeFirst() {
return KEY_TO_OBJ(REMOVE_FIRST_KEY());
}
@Override
@Deprecated
default CLASS_TYPE removeLast() {
return KEY_TO_OBJ(REMOVE_LAST_KEY());
}
#endif
/** {@inheritDoc} /** {@inheritDoc}
* <p>This default implementation delegates to the corresponding type-specific function. * <p>This default implementation delegates to the corresponding type-specific function.
* @deprecated Please use the corresponding type-specific function instead. * @deprecated Please use the corresponding type-specific function instead.
@ -558,7 +624,7 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List
@Override @Override
@Deprecated @Deprecated
public default boolean contains(Object o) { public default boolean contains(Object o) {
return COLLECTION.super.contains(o); return ORDERED_COLLECTION.super.contains(o);
} }
/** {@inheritDoc} /** {@inheritDoc}
@ -568,7 +634,7 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List
@Override @Override
@Deprecated @Deprecated
public default boolean remove(Object o) { public default boolean remove(Object o) {
return COLLECTION.super.remove(o); return ORDERED_COLLECTION.super.remove(o);
} }
/** {@inheritDoc} /** {@inheritDoc}

131
src/builder/resources/speiger/assets/collections/templates/maps/abstracts/AbstractMap.template
View File

@ -14,6 +14,15 @@ import speiger.src.collections.PACKAGE.functions.function.FUNCTION;
#endif #endif
import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR; import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR;
import speiger.src.collections.PACKAGE.maps.interfaces.MAP; 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.ABSTRACT_SET;
import speiger.src.collections.PACKAGE.sets.SET; import speiger.src.collections.PACKAGE.sets.SET;
#if MAPS_FEATURE #if MAPS_FEATURE
@ -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) { public void putAll(CLASS_TYPE[] keys, CLASS_VALUE_TYPE[] values, int offset, int size) {
SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(keys.length, offset, size);
SanityChecks.checkArrayCapacity(values.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 #endif
@ -543,6 +552,126 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap<CL
return hash; 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 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 * A Simple Type Specific Entry class to reduce boxing/unboxing
* @Type(T) * @Type(T)

199
src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/LinkedOpenCustomHashMap.template
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.sets.ORDERED_SET;
import speiger.src.collections.PACKAGE.utils.STRATEGY; 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_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.collections.VALUE_ITERATOR;
#if !SAME_TYPE #if !SAME_TYPE
import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR; 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(); 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 @Override
public boolean moveToFirst(KEY_TYPE key) { public boolean moveToFirst(KEY_TYPE key) {
if(isEmpty() || strategy.equals(FIRST_ENTRY_KEY(), key)) return false; 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]; 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 @Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() { public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
if(entrySet == null) entrySet = new MapEntrySet(); 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 @Override
public VALUE_COLLECTION VALUE_GENERIC_TYPE values() { public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
if(valuesC == null) valuesC = new Values(); if(valuesC == null) valuesC = new Values();
return valuesC; return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)valuesC;
} }
@Override @Override
@ -630,24 +724,24 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
} }
@Override @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()); return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
} }
@Override @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()); return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
} }
@Override @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()); BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
POLL_FIRST_ENTRY_KEY(); POLL_FIRST_ENTRY_KEY();
return entry; return entry;
} }
@Override @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()); BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
POLL_LAST_ENTRY_KEY(); POLL_LAST_ENTRY_KEY();
return entry; return entry;
@ -655,7 +749,12 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
@Override @Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() { 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 ReverseBiIterator<>(new EntryIterator(false));
} }
@Override @Override
@ -665,7 +764,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
@Override @Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() { public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
return new FastEntryIterator(); return new FastEntryIterator(true);
} }
@Override @Override
@ -919,7 +1018,12 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
@Override @Override
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
return new KeyIterator(); return new KeyIterator(true);
}
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return new ReverseBiIteratorBRACES(new KeyIterator(false));
} }
@Override @Override
@ -941,22 +1045,22 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
} }
@Override @Override
public KEY_TYPE FIRST_KEY() { public KEY_TYPE GET_FIRST_KEY() {
return FIRST_ENTRY_KEY(); return FIRST_ENTRY_KEY();
} }
@Override @Override
public KEY_TYPE POLL_FIRST_KEY() { public KEY_TYPE REMOVE_FIRST_KEY() {
return POLL_FIRST_ENTRY_KEY(); return POLL_FIRST_ENTRY_KEY();
} }
@Override @Override
public KEY_TYPE LAST_KEY() { public KEY_TYPE GET_LAST_KEY() {
return LAST_ENTRY_KEY(); return LAST_ENTRY_KEY();
} }
@Override @Override
public KEY_TYPE POLL_LAST_KEY() { public KEY_TYPE REMOVE_LAST_KEY() {
return POLL_LAST_ENTRY_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 #if VALUE_OBJECT
@Override @Override
@Deprecated @Deprecated
public boolean contains(Object e) { public boolean contains(Object e) { return containsValue(e); }
return containsValue(e);
}
#else #else
@Override @Override
public boolean contains(VALUE_TYPE e) { public boolean contains(VALUE_TYPE e) { return containsValue(e); }
return containsValue(e);
}
#endif #endif
@Override @Override
public boolean add(VALUE_TYPE o) { public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
throw new UnsupportedOperationException();
}
@Override @Override
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
return new ValueIterator();
}
@Override @Override
public int size() { public int size() { return LINKED_CUSTOM_HASH_MAP.this.size(); }
return LINKED_CUSTOM_HASH_MAP.this.size();
}
@Override @Override
public void clear() { public void clear() { LINKED_CUSTOM_HASH_MAP.this.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 VALUE_ABSTRACT_COLLECTION.ReverseBiIteratorVALUE_BRACES(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 @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> { private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry = new MapEntry(); MapEntry entry = new MapEntry();
public FastEntryIterator() {} public FastEntryIterator(boolean start) { super(start); }
public FastEntryIterator(KEY_TYPE from) { public FastEntryIterator(KEY_TYPE from) {
super(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> { private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry; MapEntry entry;
public EntryIterator() {} public EntryIterator(boolean start) { super(start); }
public EntryIterator(KEY_TYPE from) { public EntryIterator(KEY_TYPE from) {
super(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 { private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
public KeyIterator() {} public KeyIterator(boolean start) { super(start); }
public KeyIterator(KEY_TYPE from) { public KeyIterator(KEY_TYPE from) {
super(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 { private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
public ValueIterator() {} public ValueIterator(boolean start) { super(start); }
@Override @Override
public VALUE_TYPE VALUE_PREVIOUS() { public VALUE_TYPE VALUE_PREVIOUS() {
@ -1383,8 +1495,9 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M
int current = -1; int current = -1;
int index = 0; int index = 0;
MapIterator() { MapIterator(boolean start) {
next = firstIndex; if(start) next = firstIndex;
else previous = lastIndex;
} }
MapIterator(KEY_TYPE from) { MapIterator(KEY_TYPE from) {

198
src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/LinkedOpenHashMap.template
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.ABSTRACT_SET;
import speiger.src.collections.PACKAGE.sets.ORDERED_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_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.collections.VALUE_ITERATOR;
#if !SAME_TYPE #if !SAME_TYPE
import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR; 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(); 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 @Override
public boolean moveToFirst(KEY_TYPE key) { public boolean moveToFirst(KEY_TYPE key) {
if(isEmpty() || KEY_EQUALS(FIRST_ENTRY_KEY(), key)) return false; 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]; 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 @Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() { public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
if(entrySet == null) entrySet = new MapEntrySet(); 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 @Override
public VALUE_COLLECTION VALUE_GENERIC_TYPE values() { public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
if(valuesC == null) valuesC = new Values(); if(valuesC == null) valuesC = new Values();
return valuesC; return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)valuesC;
} }
@Override @Override
@ -634,24 +728,24 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
} }
@Override @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()); return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
} }
@Override @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()); return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
} }
@Override @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()); BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
POLL_FIRST_ENTRY_KEY(); POLL_FIRST_ENTRY_KEY();
return entry; return entry;
} }
@Override @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()); BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
POLL_LAST_ENTRY_KEY(); POLL_LAST_ENTRY_KEY();
return entry; return entry;
@ -659,7 +753,12 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
@Override @Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() { 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 ReverseBiIterator<>(new EntryIterator(false));
} }
@Override @Override
@ -669,7 +768,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
@Override @Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() { public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
return new FastEntryIterator(); return new FastEntryIterator(true);
} }
@Override @Override
@ -918,7 +1017,12 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
@Override @Override
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
return new KeyIterator(); return new KeyIterator(true);
}
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return new ReverseBiIteratorBRACES(new KeyIterator(false));
} }
@Override @Override
@ -940,22 +1044,22 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
} }
@Override @Override
public KEY_TYPE FIRST_KEY() { public KEY_TYPE GET_FIRST_KEY() {
return FIRST_ENTRY_KEY(); return FIRST_ENTRY_KEY();
} }
@Override @Override
public KEY_TYPE POLL_FIRST_KEY() { public KEY_TYPE REMOVE_FIRST_KEY() {
return POLL_FIRST_ENTRY_KEY(); return POLL_FIRST_ENTRY_KEY();
} }
@Override @Override
public KEY_TYPE LAST_KEY() { public KEY_TYPE GET_LAST_KEY() {
return LAST_ENTRY_KEY(); return LAST_ENTRY_KEY();
} }
@Override @Override
public KEY_TYPE POLL_LAST_KEY() { public KEY_TYPE REMOVE_LAST_KEY() {
return POLL_LAST_ENTRY_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 #if VALUE_OBJECT
@Override @Override
@Deprecated @Deprecated
public boolean contains(Object e) { public boolean contains(Object e) { return containsValue(e); }
return containsValue(e);
}
#else #else
@Override @Override
public boolean contains(VALUE_TYPE e) { public boolean contains(VALUE_TYPE e) { return containsValue(e); }
return containsValue(e);
}
#endif #endif
@Override @Override
public boolean add(VALUE_TYPE o) { public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
throw new UnsupportedOperationException();
}
@Override @Override
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
return new ValueIterator();
}
@Override @Override
public int size() { public int size() { return LINKED_HASH_MAP.this.size(); }
return LINKED_HASH_MAP.this.size();
}
@Override @Override
public void clear() { public void clear() { LINKED_HASH_MAP.this.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 VALUE_ABSTRACT_COLLECTION.ReverseBiIteratorVALUE_BRACES(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 @Override
public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) { public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) {
Objects.requireNonNull(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> { private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry = new MapEntry(); MapEntry entry = new MapEntry();
public FastEntryIterator() {} public FastEntryIterator(boolean start) { super(start); }
public FastEntryIterator(KEY_TYPE from) { public FastEntryIterator(KEY_TYPE from) {
super(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> { private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry; MapEntry entry;
public EntryIterator() {} public EntryIterator(boolean start) { super(start); }
public EntryIterator(KEY_TYPE from) { public EntryIterator(KEY_TYPE from) {
super(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 { private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
public KeyIterator() {} public KeyIterator(boolean start) { super(start); }
public KeyIterator(KEY_TYPE from) { public KeyIterator(KEY_TYPE from) {
super(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 { private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
public ValueIterator() {} public ValueIterator(boolean start) { super(start); }
@Override @Override
public VALUE_TYPE VALUE_PREVIOUS() { public VALUE_TYPE VALUE_PREVIOUS() {
@ -1382,8 +1495,9 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G
int current = -1; int current = -1;
int index = 0; int index = 0;
MapIterator() { MapIterator(boolean start) {
next = firstIndex; if(start) next = firstIndex;
else previous = lastIndex;
} }
MapIterator(KEY_TYPE from) { MapIterator(KEY_TYPE from) {

117
src/builder/resources/speiger/assets/collections/templates/maps/impl/immutable/ImmutableOpenHashMap.template
View File

@ -65,7 +65,7 @@ import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE;
import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET; import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET;
#endif #endif
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION; 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.collections.VALUE_ITERATOR;
import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER; import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER;
#if !SAME_TYPE #if !SAME_TYPE
@ -119,7 +119,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
/** KeySet cache */ /** KeySet cache */
protected transient ORDERED_SET KEY_GENERIC_TYPE keySet; protected transient ORDERED_SET KEY_GENERIC_TYPE keySet;
/** Values cache */ /** 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 */ /** Amount of Elements stored in the HashMap */
protected int size; protected int size;
@ -320,6 +320,10 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
@Override @Override
public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); } public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
@Override @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(); } public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
@Override @Override
public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); } 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() { public VALUE_TYPE LAST_ENTRY_VALUE() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
return values[lastIndex]; 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 @Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() { 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 @Override
public VALUE_COLLECTION VALUE_GENERIC_TYPE values() { public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
if(valuesC == null) valuesC = new Values(); if(valuesC == null) valuesC = new Values();
return valuesC; 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(); } public boolean moveToLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); }
@Override @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()); return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
} }
@Override @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()); return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
} }
@Override @Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() { throw new UnsupportedOperationException(); } public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() { throw new UnsupportedOperationException(); }
@Override @Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() { throw new UnsupportedOperationException(); } public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() { throw new UnsupportedOperationException(); }
@Override @Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() { 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 ReverseBiIterator<>(new EntryIterator(false));
} }
@Override @Override
@ -648,7 +674,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
@Override @Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() { public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
return new FastEntryIterator(); return new FastEntryIterator(true);
} }
@Override @Override
@ -875,7 +901,12 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
@Override @Override
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
return new KeyIterator(); return new KeyIterator(true);
}
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return new ReverseBiIteratorBRACES(new KeyIterator(false));
} }
@Override @Override
@ -895,20 +926,20 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
public void clear() { throw new UnsupportedOperationException(); } public void clear() { throw new UnsupportedOperationException(); }
@Override @Override
public KEY_TYPE FIRST_KEY() { public KEY_TYPE GET_FIRST_KEY() {
return FIRST_ENTRY_KEY(); return FIRST_ENTRY_KEY();
} }
@Override @Override
public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); } public KEY_TYPE REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); }
@Override @Override
public KEY_TYPE LAST_KEY() { public KEY_TYPE GET_LAST_KEY() {
return LAST_ENTRY_KEY(); return LAST_ENTRY_KEY();
} }
@Override @Override
public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); } public KEY_TYPE REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); }
@Override @Override
public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) { 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 #if VALUE_OBJECT
@Override @Override
@Deprecated @Deprecated
public boolean contains(Object e) { public boolean contains(Object e) { return containsValue(e); }
return containsValue(e);
}
#else #else
@Override @Override
public boolean contains(VALUE_TYPE e) { public boolean contains(VALUE_TYPE e) { return containsValue(e); }
return containsValue(e);
}
#endif #endif
@Override @Override
public boolean add(VALUE_TYPE o) { public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
throw new UnsupportedOperationException();
}
@Override @Override
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
return new ValueIterator();
}
@Override @Override
public int size() { public int size() { return IMMUTABLE_HASH_MAP.this.size(); }
return IMMUTABLE_HASH_MAP.this.size();
}
@Override @Override
public void clear() { throw new UnsupportedOperationException(); } 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 VALUE_ABSTRACT_COLLECTION.ReverseBiIteratorVALUE_BRACES(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 @Override
public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) { public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) {
int index = firstIndex; 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> { private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry = new MapEntry(); MapEntry entry = new MapEntry();
public FastEntryIterator() {} public FastEntryIterator(boolean start) { super(start); }
public FastEntryIterator(KEY_TYPE from) { public FastEntryIterator(KEY_TYPE from) {
super(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> { 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) { public EntryIterator(KEY_TYPE from) {
super(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 { private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
public KeyIterator() {} public KeyIterator(boolean start) { super(start); }
public KeyIterator(KEY_TYPE from) { public KeyIterator(KEY_TYPE from) {
super(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 { private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
public ValueIterator() {} public ValueIterator(boolean start) { super(start); }
@Override @Override
public VALUE_TYPE VALUE_PREVIOUS() { public VALUE_TYPE VALUE_PREVIOUS() {
@ -1327,8 +1361,9 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_
int current = -1; int current = -1;
int index = 0; int index = 0;
MapIterator() { MapIterator(boolean start) {
next = firstIndex; if(start) next = firstIndex;
else previous = lastIndex;
} }
MapIterator(KEY_TYPE from) { MapIterator(KEY_TYPE from) {

171
src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template
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.ABSTRACT_SET;
import speiger.src.collections.PACKAGE.sets.ORDERED_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_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.collections.VALUE_ITERATOR;
import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER; import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER;
#if !SAME_TYPE #if !SAME_TYPE
@ -105,7 +105,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
/** KeySet cache */ /** KeySet cache */
protected ORDERED_SET KEY_GENERIC_TYPE keySet; protected ORDERED_SET KEY_GENERIC_TYPE keySet;
/** Values cache */ /** Values cache */
protected VALUE_COLLECTION VALUE_GENERIC_TYPE valuesC; protected VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE valuesC;
/** EntrySet cache */ /** EntrySet cache */
protected FastOrderedSet KEY_VALUE_GENERIC_TYPE entrySet; 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; 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 @Override
public boolean moveToFirst(KEY_TYPE key) { public boolean moveToFirst(KEY_TYPE key) {
int index = findIndex(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; 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 @Override
public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) { public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) {
int index = findIndex(key); int index = findIndex(key);
@ -461,7 +510,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
} }
@Override @Override
public VALUE_COLLECTION VALUE_GENERIC_TYPE values() { public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
if(valuesC == null) valuesC = new Values(); if(valuesC == null) valuesC = new Values();
return valuesC; return valuesC;
} }
@ -828,24 +877,24 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
} }
@Override @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()); return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
} }
@Override @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()); return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
} }
@Override @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()); BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
POLL_FIRST_ENTRY_KEY(); POLL_FIRST_ENTRY_KEY();
return entry; return entry;
} }
@Override @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()); BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
POLL_LAST_ENTRY_KEY(); POLL_LAST_ENTRY_KEY();
return entry; return entry;
@ -853,7 +902,12 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
@Override @Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() { 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 ReverseBiIterator<>(new EntryIterator(false));
} }
@Override @Override
@ -863,7 +917,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
@Override @Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() { public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
return new FastEntryIterator(); return new FastEntryIterator(true);
} }
@Override @Override
@ -1073,7 +1127,9 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
@Override @Override
public boolean moveToLast(KEY_TYPE o) { return ARRAY_MAP.this.moveToLast(o); } public boolean moveToLast(KEY_TYPE o) { return ARRAY_MAP.this.moveToLast(o); }
@Override @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 ReverseBiIteratorBRACES(new KeyIterator(false)); }
@Override @Override
public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { return new KeyIterator(fromElement); } public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { return new KeyIterator(fromElement); }
@Override @Override
@ -1081,13 +1137,13 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
@Override @Override
public void clear() { ARRAY_MAP.this.clear(); } public void clear() { ARRAY_MAP.this.clear(); }
@Override @Override
public KEY_TYPE FIRST_KEY() { return FIRST_ENTRY_KEY(); } public KEY_TYPE GET_FIRST_KEY() { return FIRST_ENTRY_KEY(); }
@Override @Override
public KEY_TYPE POLL_FIRST_KEY() { return POLL_FIRST_ENTRY_KEY(); } public KEY_TYPE REMOVE_FIRST_KEY() { return POLL_FIRST_ENTRY_KEY(); }
@Override @Override
public KEY_TYPE LAST_KEY() { return LAST_ENTRY_KEY(); } public KEY_TYPE GET_LAST_KEY() { return LAST_ENTRY_KEY(); }
@Override @Override
public KEY_TYPE POLL_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); } public KEY_TYPE REMOVE_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); }
@Override @Override
public KeySet copy() { throw new UnsupportedOperationException(); } 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 #if VALUE_OBJECT
@Override @Override
public boolean contains(Object e) { public boolean contains(Object e) { return containsValue(e); }
return containsValue(e);
}
#else #else
@Override @Override
public boolean contains(VALUE_TYPE e) { public boolean contains(VALUE_TYPE e) { return containsValue(e); }
return containsValue(e);
}
#endif #endif
@Override @Override
public boolean add(VALUE_TYPE o) { public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
throw new UnsupportedOperationException();
}
@Override @Override
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
return new ValueIterator();
}
@Override @Override
public int size() { public int size() { return ARRAY_MAP.this.size(); }
return ARRAY_MAP.this.size();
}
@Override @Override
public void clear() { public void clear() { ARRAY_MAP.this.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 VALUE_ABSTRACT_COLLECTION.ReverseBiIteratorVALUE_BRACES(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 @Override
public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) { public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) {
Objects.requireNonNull(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> { private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry = new MapEntry(); MapEntry entry = new MapEntry();
public FastEntryIterator() {} public FastEntryIterator(boolean start) { super(start); }
public FastEntryIterator(KEY_TYPE from) { public FastEntryIterator(KEY_TYPE element) { super(element); }
index = findIndex(from);
}
@Override @Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE next() { 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> { private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry = null; MapEntry entry = null;
public EntryIterator() {} public EntryIterator(boolean start) { super(start); }
public EntryIterator(KEY_TYPE from) { public EntryIterator(KEY_TYPE element) { super(element); }
index = findIndex(from);
if(index == -1) throw new NoSuchElementException();
}
@Override @Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE next() { 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 { private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
public KeyIterator() {} public KeyIterator(boolean start) { super(start); }
public KeyIterator(KEY_TYPE element) { public KeyIterator(KEY_TYPE element) { super(element); }
index = findIndex(element);
if(index == -1) throw new NoSuchElementException();
}
@Override @Override
public KEY_TYPE PREVIOUS() { 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 { 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 @Override
public VALUE_TYPE VALUE_PREVIOUS() { public VALUE_TYPE VALUE_PREVIOUS() {
return values[previousEntry()]; return values[previousEntry()];
@ -1433,7 +1493,16 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN
private class MapIterator { private class MapIterator {
int index; int index;
int lastReturned = -1; int lastReturned = -1;
MapIterator(boolean start) {
this.index = start ? 0 : size;
}
MapIterator(KEY_TYPE element) {
index = findIndex(element);
if(index == -1) throw new NoSuchElementException();
}
public boolean hasNext() { public boolean hasNext() {
return index < size; return index < size;
} }

162
src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/LinkedEnumMap.template
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.ABSTRACT_SET;
import speiger.src.collections.PACKAGE.sets.ORDERED_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_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.collections.VALUE_ITERATOR;
#if !VALUE_OBJECT && !SAME_TYPE #if !VALUE_OBJECT && !SAME_TYPE
import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_CONSUMER; 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(); 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 @Override
public boolean moveToFirst(T key) { public boolean moveToFirst(T key) {
int index = key.ordinal(); 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]; 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 @Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() { public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
if(entrySet == null) entrySet = new MapEntrySet(); 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 @Override
public VALUE_COLLECTION VALUE_GENERIC_TYPE values() { public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
if(valuesC == null) valuesC = new Values(); if(valuesC == null) valuesC = new Values();
return valuesC; return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)valuesC;
} }
@Override @Override
@ -431,24 +489,24 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
} }
@Override @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()); return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
} }
@Override @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()); return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
} }
@Override @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()); BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE());
POLL_FIRST_ENTRY_KEY(); POLL_FIRST_ENTRY_KEY();
return entry; return entry;
} }
@Override @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()); BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE());
POLL_LAST_ENTRY_KEY(); POLL_LAST_ENTRY_KEY();
return entry; return entry;
@ -456,7 +514,12 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
@Override @Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() { 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 ReverseBiIterator<>(new EntryIterator(false));
} }
@Override @Override
@ -466,7 +529,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
@Override @Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() { public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> fastIterator() {
return new FastEntryIterator(); return new FastEntryIterator(true);
} }
@Override @Override
@ -593,7 +656,12 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
@Override @Override
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
return new KeyIterator(); return new KeyIterator(true);
}
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return new ReverseBiIteratorBRACES(new KeyIterator(false));
} }
@Override @Override
@ -614,22 +682,22 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
} }
@Override @Override
public T FIRST_KEY() { public T GET_FIRST_KEY() {
return FIRST_ENTRY_KEY(); return FIRST_ENTRY_KEY();
} }
@Override @Override
public T POLL_FIRST_KEY() { public T REMOVE_FIRST_KEY() {
return POLL_FIRST_ENTRY_KEY(); return POLL_FIRST_ENTRY_KEY();
} }
@Override @Override
public T LAST_KEY() { public T GET_LAST_KEY() {
return LAST_ENTRY_KEY(); return LAST_ENTRY_KEY();
} }
@Override @Override
public T POLL_LAST_KEY() { public T REMOVE_LAST_KEY() {
return POLL_LAST_ENTRY_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 #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 #if VALUE_OBJECT
@Override @Override
@Deprecated @Deprecated
public boolean contains(Object e) { public boolean contains(Object e) { return containsValue(e); }
return containsValue(e);
}
#else #else
@Override @Override
public boolean contains(VALUE_TYPE e) { public boolean contains(VALUE_TYPE e) { return containsValue(e); }
return containsValue(e);
}
#endif #endif
@Override @Override
public boolean add(VALUE_TYPE o) { public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); }
throw new UnsupportedOperationException();
}
@Override @Override
public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); }
return new ValueIterator();
}
@Override @Override
public int size() { public int size() { return LINKED_ENUM_MAP.this.size(); }
return LINKED_ENUM_MAP.this.size();
}
@Override @Override
public void clear() { public void clear() { LINKED_ENUM_MAP.this.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 VALUE_ABSTRACT_COLLECTION.ReverseBiIteratorVALUE_BRACES(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 #if VALUE_OBJECT
@Override @Override
public void forEach(Consumer VALUE_SUPER_GENERIC_TYPE action) { 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> { private class FastEntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry = new MapEntry(); MapEntry entry = new MapEntry();
public FastEntryIterator() {} public FastEntryIterator(boolean start) { super(start); }
public FastEntryIterator(T from) { public FastEntryIterator(T from) {
super(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> { private class EntryIterator extends MapIterator implements ObjectListIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> {
MapEntry entry; MapEntry entry;
public EntryIterator() {} public EntryIterator(boolean start) { super(start); }
public EntryIterator(T from) { public EntryIterator(T from) {
super(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 { private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE {
public KeyIterator() {} public KeyIterator(boolean start) { super(start); }
public KeyIterator(T from) { public KeyIterator(T from) {
super(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 { private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE {
public ValueIterator() {} public ValueIterator(boolean start) { super(start); }
@Override @Override
public VALUE_TYPE VALUE_PREVIOUS() { public VALUE_TYPE VALUE_PREVIOUS() {
@ -820,8 +897,9 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA
int current = -1; int current = -1;
int index = 0; int index = 0;
MapIterator() { MapIterator(boolean start) {
next = firstIndex; if(start) next = firstIndex;
else previous = lastIndex;
} }
MapIterator(T from) { MapIterator(T from) {

2
src/builder/resources/speiger/assets/collections/templates/maps/interfaces/Map.template
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. * @return the last present value or default return value.
*/ */
public default CLASS_VALUE_TYPE put(Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE> entry) { 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 #endif

68
src/builder/resources/speiger/assets/collections/templates/maps/interfaces/OrderedMap.template
View File

@ -1,8 +1,15 @@
package speiger.src.collections.PACKAGE.maps.interfaces; package speiger.src.collections.PACKAGE.maps.interfaces;
#if JAVA_VERSION>=21
import java.util.Map;
import java.util.SequencedMap;
#endif
#if MAPS_FEATURE #if MAPS_FEATURE
import speiger.src.collections.PACKAGE.utils.maps.MAPS; import speiger.src.collections.PACKAGE.utils.maps.MAPS;
#endif #endif
import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
#if !TYPE_OBJECT #if !TYPE_OBJECT
import speiger.src.collections.PACKAGE.sets.ORDERED_SET; import speiger.src.collections.PACKAGE.sets.ORDERED_SET;
#endif #endif
@ -17,7 +24,11 @@ import speiger.src.collections.objects.sets.ObjectOrderedSet;
* @Type(T) * @Type(T)
* @ValueType(V) * @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 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. * 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); 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. * A specific move method to move a given key/value to the first index.
* @param key that should be moved 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(); 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 @Override
public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy(); public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy();
@Override @Override
public ORDERED_SET KEY_GENERIC_TYPE keySet(); public ORDERED_SET KEY_GENERIC_TYPE keySet();
@Override @Override
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values();
@Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET(); 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 #if MAPS_FEATURE
/** /**
* Creates a Wrapped SortedMap that is Synchronized * 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 @Override
public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE unmodifiable() { return MAPS.unmodifiable(this); } 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 #endif
/** /**
* Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value * Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value

92
src/builder/resources/speiger/assets/collections/templates/sets/AbstractSet.template
View File

@ -6,6 +6,7 @@ import java.util.Objects;
import java.util.Set; import java.util.Set;
import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION; import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION;
import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
import speiger.src.collections.PACKAGE.collections.ITERATOR; import speiger.src.collections.PACKAGE.collections.ITERATOR;
/** /**
@ -47,4 +48,95 @@ public abstract class ABSTRACT_SET KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
return false; return false;
} }
} }
#if ORDERED_SET_FEATURE
public static class REVERSED_ORDERED_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE implements ORDERED_SET KEY_GENERIC_TYPE {
protected ORDERED_SET KEY_GENERIC_TYPE set;
public REVERSED_ORDERED_SET(ORDERED_SET KEY_GENERIC_TYPE set) {
this.set = set;
}
@Override
public REVERSED_ORDERED_SET KEY_GENERIC_TYPE copy() { throw new UnsupportedOperationException(); }
@Override
public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
return set.iterator(fromElement);
}
@Override
public BI_ITERATOR KEY_GENERIC_TYPE iterator() {
return set.reverseIterator();
}
@Override
public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return set.iterator();
}
@Override
#if !TYPE_OBJECT
public boolean remove(KEY_TYPE o) {
#else
public boolean remove(Object o) {
#endif
return set.remove(o);
}
@Override
public boolean add(KEY_TYPE o) {
return set.add(o);
}
@Override
public boolean addAndMoveToFirst(KEY_TYPE o) {
return set.addAndMoveToLast(o);
}
@Override
public boolean addAndMoveToLast(KEY_TYPE o) {
return set.addAndMoveToFirst(o);
}
@Override
public boolean moveToFirst(KEY_TYPE o) {
return set.moveToLast(o);
}
@Override
public boolean moveToLast(KEY_TYPE o) {
return set.moveToFirst(o);
}
@Override
public KEY_TYPE GET_FIRST_KEY() {
return set.GET_LAST_KEY();
}
@Override
public KEY_TYPE REMOVE_FIRST_KEY() {
return set.REMOVE_LAST_KEY();
}
@Override
public KEY_TYPE GET_LAST_KEY() {
return set.GET_FIRST_KEY();
}
@Override
public KEY_TYPE REMOVE_LAST_KEY() {
return set.REMOVE_FIRST_KEY();
}
@Override
public ORDERED_SET KEY_GENERIC_TYPE reversed() {
return set;
}
@Override
public int size() {
return set.size();
}
}
#endif
} }

13
src/builder/resources/speiger/assets/collections/templates/sets/ArraySet.template
View File

@ -219,13 +219,13 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
#endif #endif
@Override @Override
public KEY_TYPE FIRST_KEY() { public KEY_TYPE GET_FIRST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
return data[0]; return data[0];
} }
@Override @Override
public KEY_TYPE LAST_KEY() { public KEY_TYPE GET_LAST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
return data[size - 1]; return data[size - 1];
} }
@ -354,7 +354,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
#endif #endif
@Override @Override
public KEY_TYPE POLL_FIRST_KEY() { public KEY_TYPE REMOVE_FIRST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
KEY_TYPE result = data[0]; KEY_TYPE result = data[0];
System.arraycopy(data, 1, data, 0, --size); System.arraycopy(data, 1, data, 0, --size);
@ -365,7 +365,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
} }
@Override @Override
public KEY_TYPE POLL_LAST_KEY() { public KEY_TYPE REMOVE_LAST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
size--; size--;
#if TYPE_OBJECT #if TYPE_OBJECT
@ -514,6 +514,11 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im
return new SetIterator(0); return new SetIterator(0);
} }
@Override
public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return new ReverseBiIteratorBRACES(new SetIterator(size));
}
@Override @Override
public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) {
int index = findIndex(fromElement); int index = findIndex(fromElement);

20
src/builder/resources/speiger/assets/collections/templates/sets/ImmutableOpenHashSet.template
View File

@ -285,22 +285,22 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
} }
@Override @Override
public KEY_TYPE FIRST_KEY() { public KEY_TYPE GET_FIRST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
return keys[firstIndex]; return keys[firstIndex];
} }
@Override @Override
public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); } public KEY_TYPE REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); }
@Override @Override
public KEY_TYPE LAST_KEY() { public KEY_TYPE GET_LAST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
return keys[lastIndex]; return keys[lastIndex];
} }
@Override @Override
public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); } public KEY_TYPE REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); }
@Override @Override
public boolean remove(Object o) { throw new UnsupportedOperationException(); } public boolean remove(Object o) { throw new UnsupportedOperationException(); }
@ -455,7 +455,12 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
@Override @Override
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
return new SetIterator(); return new SetIterator(true);
}
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return new ReverseBiIteratorBRACES(new SetIterator(false));
} }
@Override @Override
@ -526,8 +531,9 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI
int current = -1; int current = -1;
int index = 0; int index = 0;
SetIterator() { SetIterator(boolean start) {
next = firstIndex; if(start) next = firstIndex;
else previous = lastIndex;
} }
SetIterator(KEY_TYPE from) { SetIterator(KEY_TYPE from) {

24
src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenCustomHashSet.template
View File

@ -291,7 +291,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
@Override @Override
public boolean moveToFirst(KEY_TYPE o) { public boolean moveToFirst(KEY_TYPE o) {
if(isEmpty() || strategy.equals(FIRST_KEY(), o)) return false; if(isEmpty() || strategy.equals(GET_FIRST_KEY(), o)) return false;
if(strategy.equals(o, EMPTY_KEY_VALUE)) { if(strategy.equals(o, EMPTY_KEY_VALUE)) {
if(containsNull) { if(containsNull) {
moveToFirstIndex(nullIndex); moveToFirstIndex(nullIndex);
@ -313,7 +313,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
@Override @Override
public boolean moveToLast(KEY_TYPE o) { public boolean moveToLast(KEY_TYPE o) {
if(isEmpty() || strategy.equals(LAST_KEY(), o)) return false; if(isEmpty() || strategy.equals(GET_LAST_KEY(), o)) return false;
if(strategy.equals(o, EMPTY_KEY_VALUE)) { if(strategy.equals(o, EMPTY_KEY_VALUE)) {
if(containsNull) { if(containsNull) {
moveToLastIndex(nullIndex); moveToLastIndex(nullIndex);
@ -370,13 +370,13 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
} }
@Override @Override
public KEY_TYPE FIRST_KEY() { public KEY_TYPE GET_FIRST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
return keys[firstIndex]; return keys[firstIndex];
} }
@Override @Override
public KEY_TYPE POLL_FIRST_KEY() { public KEY_TYPE REMOVE_FIRST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
int pos = firstIndex; int pos = firstIndex;
onNodeRemoved(pos); onNodeRemoved(pos);
@ -392,13 +392,13 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
} }
@Override @Override
public KEY_TYPE LAST_KEY() { public KEY_TYPE GET_LAST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
return keys[lastIndex]; return keys[lastIndex];
} }
@Override @Override
public KEY_TYPE POLL_LAST_KEY() { public KEY_TYPE REMOVE_LAST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
int pos = lastIndex; int pos = lastIndex;
onNodeRemoved(pos); onNodeRemoved(pos);
@ -697,7 +697,12 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
@Override @Override
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
return new SetIterator(); return new SetIterator(true);
}
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return new ReverseBiIteratorBRACES(new SetIterator(false));
} }
@Override @Override
@ -727,8 +732,9 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY
int current = -1; int current = -1;
int index = 0; int index = 0;
SetIterator() { SetIterator(boolean start) {
next = firstIndex; if(start) next = firstIndex;
else previous = lastIndex;
} }
SetIterator(KEY_TYPE from) { SetIterator(KEY_TYPE from) {

24
src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenHashSet.template
View File

@ -262,7 +262,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
@Override @Override
public boolean moveToFirst(KEY_TYPE o) { public boolean moveToFirst(KEY_TYPE o) {
if(isEmpty() || KEY_EQUALS(FIRST_KEY(), o)) return false; if(isEmpty() || KEY_EQUALS(GET_FIRST_KEY(), o)) return false;
if(KEY_EQUALS_NULL(o)) { if(KEY_EQUALS_NULL(o)) {
if(containsNull) { if(containsNull) {
moveToFirstIndex(nullIndex); moveToFirstIndex(nullIndex);
@ -284,7 +284,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
@Override @Override
public boolean moveToLast(KEY_TYPE o) { public boolean moveToLast(KEY_TYPE o) {
if(isEmpty() || KEY_EQUALS(LAST_KEY(), o)) return false; if(isEmpty() || KEY_EQUALS(GET_LAST_KEY(), o)) return false;
if(KEY_EQUALS_NULL(o)) { if(KEY_EQUALS_NULL(o)) {
if(containsNull) { if(containsNull) {
moveToLastIndex(nullIndex); moveToLastIndex(nullIndex);
@ -341,13 +341,13 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
} }
@Override @Override
public KEY_TYPE FIRST_KEY() { public KEY_TYPE GET_FIRST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
return keys[firstIndex]; return keys[firstIndex];
} }
@Override @Override
public KEY_TYPE POLL_FIRST_KEY() { public KEY_TYPE REMOVE_FIRST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
int pos = firstIndex; int pos = firstIndex;
onNodeRemoved(pos); onNodeRemoved(pos);
@ -363,13 +363,13 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
} }
@Override @Override
public KEY_TYPE LAST_KEY() { public KEY_TYPE GET_LAST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
return keys[lastIndex]; return keys[lastIndex];
} }
@Override @Override
public KEY_TYPE POLL_LAST_KEY() { public KEY_TYPE REMOVE_LAST_KEY() {
if(size == 0) throw new NoSuchElementException(); if(size == 0) throw new NoSuchElementException();
int pos = lastIndex; int pos = lastIndex;
onNodeRemoved(pos); onNodeRemoved(pos);
@ -668,7 +668,12 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
@Override @Override
public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { public LIST_ITERATOR KEY_GENERIC_TYPE iterator() {
return new SetIterator(); return new SetIterator(true);
}
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() {
return new ReverseBiIteratorBRACES(new SetIterator(false));
} }
@Override @Override
@ -698,8 +703,9 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE
int current = -1; int current = -1;
int index = 0; int index = 0;
SetIterator() { SetIterator(boolean start) {
next = firstIndex; if(start) next = firstIndex;
else previous = lastIndex;
} }
SetIterator(KEY_TYPE from) { SetIterator(KEY_TYPE from) {

71
src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template
View File

@ -1,10 +1,15 @@
package speiger.src.collections.PACKAGE.sets; package speiger.src.collections.PACKAGE.sets;
#if JAVA_VERSION>=21
import java.util.SequencedSet;
#endif
import speiger.src.collections.PACKAGE.collections.BI_ITERATOR; import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
#if SPLIT_ITERATOR_FEATURE #if SPLIT_ITERATOR_FEATURE
import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
#endif #endif
import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET.REVERSED_ORDERED_SET;
#if SETS_FEATURE #if SETS_FEATURE
import speiger.src.collections.PACKAGE.utils.SETS; import speiger.src.collections.PACKAGE.utils.SETS;
#endif #endif
@ -17,7 +22,11 @@ import speiger.src.collections.PACKAGE.utils.SETS;
* *
* @Type(T) * @Type(T)
*/ */
#if JAVA_VERSION>=21
public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, SequencedSet<CLASS_TYPE>
#else
public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE
#endif
{ {
/** /**
* A customized add method that allows you to insert into the first index. * A customized add method that allows you to insert into the first index.
@ -54,6 +63,7 @@ public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE
@Override @Override
public BI_ITERATOR KEY_GENERIC_TYPE iterator(); public BI_ITERATOR KEY_GENERIC_TYPE iterator();
public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator();
/** /**
* A type Specific Iterator starting from a given key * A type Specific Iterator starting from a given key
@ -76,23 +86,76 @@ public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE
* A method to get the first element in the set * A method to get the first element in the set
* @return first element in the set * @return first element in the set
*/ */
public KEY_TYPE FIRST_KEY(); public KEY_TYPE GET_FIRST_KEY();
/** /**
* A method to get and remove the first element in the set * A method to get and remove the first element in the set
* @return first element in the set * @return first element in the set
*/ */
public KEY_TYPE POLL_FIRST_KEY(); public KEY_TYPE REMOVE_FIRST_KEY();
/** /**
* A method to get the last element in the set * A method to get the last element in the set
* @return last element in the set * @return last element in the set
*/ */
public KEY_TYPE LAST_KEY(); public KEY_TYPE GET_LAST_KEY();
/** /**
* A method to get and remove the last element in the set * A method to get and remove the last element in the set
* @return last element in the set * @return last element in the set
*/ */
public KEY_TYPE POLL_LAST_KEY(); public KEY_TYPE REMOVE_LAST_KEY();
#if JAVA_VERSION>=21 && !TYPE_OBJECT
/** {@inheritDoc}
* <p>This default implementation delegates to the corresponding type-specific function.
* @deprecated Please use the corresponding type-specific function instead.
*/
@Override
@Deprecated
default void addFirst(CLASS_TYPE e) { addAndMoveToFirst(OBJ_TO_KEY(e)); }
/** {@inheritDoc}
* <p>This default implementation delegates to the corresponding type-specific function.
* @deprecated Please use the corresponding type-specific function instead.
*/
@Override
@Deprecated
default void addLast(CLASS_TYPE e) { addAndMoveToLast(OBJ_TO_KEY(e)); }
/** {@inheritDoc}
* <p>This default implementation delegates to the corresponding type-specific function.
* @deprecated Please use the corresponding type-specific function instead.
*/
@Override
@Deprecated
default CLASS_TYPE getFirst() { return GET_FIRST_KEY(); }
/** {@inheritDoc}
* <p>This default implementation delegates to the corresponding type-specific function.
* @deprecated Please use the corresponding type-specific function instead.
*/
@Override
@Deprecated
default CLASS_TYPE getLast() { return GET_LAST_KEY(); }
/** {@inheritDoc}
* <p>This default implementation delegates to the corresponding type-specific function.
* @deprecated Please use the corresponding type-specific function instead.
*/
@Override
@Deprecated
default CLASS_TYPE removeFirst() { return REMOVE_FIRST_KEY(); }
/** {@inheritDoc}
* <p>This default implementation delegates to the corresponding type-specific function.
* @deprecated Please use the corresponding type-specific function instead.
*/
@Override
@Deprecated
default CLASS_TYPE removeLast() { return REMOVE_LAST_KEY(); }
#endif
@Java21
public default ORDERED_SET KEY_GENERIC_TYPE reversed() { return new REVERSED_ORDERED_SETBRACES(this); }
#if SETS_FEATURE #if SETS_FEATURE
/** /**
* Creates a Wrapped OrderedSet that is Synchronized * Creates a Wrapped OrderedSet that is Synchronized

94
src/builder/resources/speiger/assets/collections/templates/utils/Collections.template
View File

@ -23,6 +23,9 @@ import java.util.function.Consumer;
import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION; import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION;
import speiger.src.collections.PACKAGE.collections.COLLECTION; import speiger.src.collections.PACKAGE.collections.COLLECTION;
#if ORDERED_MAP_FEATURE
import speiger.src.collections.PACKAGE.collections.ORDERED_COLLECTION;
#endif
import speiger.src.collections.PACKAGE.collections.ITERATOR; import speiger.src.collections.PACKAGE.collections.ITERATOR;
#if !TYPE_OBJECT #if !TYPE_OBJECT
import speiger.src.collections.PACKAGE.functions.COMPARATOR; import speiger.src.collections.PACKAGE.functions.COMPARATOR;
@ -76,6 +79,37 @@ public class COLLECTIONS
return c instanceof UnmodifiableCollection ? c : new UnmodifiableCollectionBRACES(c); return c instanceof UnmodifiableCollection ? c : new UnmodifiableCollectionBRACES(c);
} }
/**
* Returns a Immutable Ordered Collection instance based on the instance given.
* @param c that should be made immutable/unmodifiable
* @Type(T)
* @return a unmodifiable Ordered collection wrapper. If the Collection already a unmodifiable wrapper then it just returns itself.
*/
public static GENERIC_KEY_BRACES ORDERED_COLLECTION KEY_GENERIC_TYPE unmodifiable(ORDERED_COLLECTION KEY_GENERIC_TYPE c) {
return c instanceof UnmodifiableOrderedCollection ? c : new UnmodifiableOrderedCollectionBRACES(c);
}
/**
* Returns a synchronized ordered Collection instance based on the instance given.
* @param c that should be synchronized
* @Type(T)
* @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself.
*/
public static GENERIC_KEY_BRACES ORDERED_COLLECTION KEY_GENERIC_TYPE synchronize(ORDERED_COLLECTION KEY_GENERIC_TYPE c) {
return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollectionBRACES(c);
}
/**
* Returns a synchronized ordered Collection instance based on the instance given.
* @param c that should be synchronized
* @param mutex is the controller of the synchronization block.
* @Type(T)
* @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself.
*/
public static GENERIC_KEY_BRACES ORDERED_COLLECTION KEY_GENERIC_TYPE synchronize(ORDERED_COLLECTION KEY_GENERIC_TYPE c, Object mutex) {
return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollectionBRACES(c, mutex);
}
/** /**
* Returns a synchronized Collection instance based on the instance given. * Returns a synchronized Collection instance based on the instance given.
* @param c that should be synchronized * @param c that should be synchronized
@ -668,6 +702,38 @@ public class COLLECTIONS
@Override @Override
public SingletonCollection KEY_GENERIC_TYPE copy() { return new SingletonCollectionBRACES(element); } public SingletonCollection KEY_GENERIC_TYPE copy() { return new SingletonCollectionBRACES(element); }
} }
/**
* Synchronized Ordered Collection Wrapper for the synchronizedCollection function
* @Type(T)
*/
public static class SynchronizedOrderedCollection KEY_GENERIC_TYPE extends SynchronizedCollection KEY_GENERIC_TYPE implements ORDERED_COLLECTION KEY_GENERIC_TYPE {
ORDERED_COLLECTION KEY_GENERIC_TYPE c;
SynchronizedOrderedCollection(ORDERED_COLLECTION KEY_GENERIC_TYPE c, Object mutex) {
super(c, mutex);
this.c = c;
}
SynchronizedOrderedCollection(ORDERED_COLLECTION KEY_GENERIC_TYPE c) {
super(c);
this.c = c;
}
@Override
public ORDERED_COLLECTION KEY_GENERIC_TYPE reversed() { return COLLECTIONS.synchronize(c.reversed(), mutex); }
@Override
public void addFirst(KEY_TYPE e) { synchronized(mutex) { this.c.addFirst(e); } }
@Override
public void addLast(KEY_TYPE e) { synchronized(mutex) { this.c.addLast(e); } }
@Override
public KEY_TYPE GET_FIRST_KEY() { synchronized(mutex) { return this.c.GET_FIRST_KEY(); } }
@Override
public KEY_TYPE REMOVE_FIRST_KEY() { synchronized(mutex) { return this.c.REMOVE_FIRST_KEY(); } }
@Override
public KEY_TYPE GET_LAST_KEY() { synchronized(mutex) { return this.c.GET_LAST_KEY(); } }
@Override
public KEY_TYPE REMOVE_LAST_KEY() { synchronized(mutex) { return this.c.REMOVE_LAST_KEY(); } }
}
/** /**
* Synchronized Collection Wrapper for the synchronizedCollection function * Synchronized Collection Wrapper for the synchronizedCollection function
@ -810,6 +876,34 @@ public class COLLECTIONS
public int count(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return c.count(filter); } } public int count(PREDICATE KEY_GENERIC_TYPE filter) { synchronized(mutex) { return c.count(filter); } }
} }
/**
* Unmodifyable Ordered Collection Wrapper for the unmodifyableCollection method
* @Type(T)
*/
public static class UnmodifiableOrderedCollection KEY_GENERIC_TYPE extends UnmodifiableCollection KEY_GENERIC_TYPE implements ORDERED_COLLECTION KEY_GENERIC_TYPE {
ORDERED_COLLECTION KEY_GENERIC_TYPE c;
UnmodifiableOrderedCollection(ORDERED_COLLECTION KEY_GENERIC_TYPE c) {
super(c);
this.c = c;
}
@Override
public ORDERED_COLLECTION KEY_GENERIC_TYPE reversed() { return COLLECTIONS.unmodifiable(c.reversed()); }
@Override
public void addFirst(KEY_TYPE e) { throw new UnsupportedOperationException(); }
@Override
public void addLast(KEY_TYPE e) { throw new UnsupportedOperationException(); }
@Override
public KEY_TYPE GET_FIRST_KEY() { return c.GET_FIRST_KEY(); }
@Override
public KEY_TYPE REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); }
@Override
public KEY_TYPE GET_LAST_KEY() { return c.GET_LAST_KEY(); }
@Override
public KEY_TYPE REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); }
}
/** /**
* Unmodifyable Collection Wrapper for the unmodifyableCollection method * Unmodifyable Collection Wrapper for the unmodifyableCollection method
* @Type(T) * @Type(T)

6
src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template
View File

@ -65,7 +65,7 @@ public class ITERATORS
* @Type(T) * @Type(T)
* @return an empty iterator * @return an empty iterator
*/ */
public static GENERIC_KEY_BRACES EmptyIterator KEY_GENERIC_TYPE empty() { public static GENERIC_KEY_BRACES LIST_ITERATOR KEY_GENERIC_TYPE empty() {
#if TYPE_OBJECT #if TYPE_OBJECT
return (EmptyIterator<KEY_TYPE>)EMPTY; return (EmptyIterator<KEY_TYPE>)EMPTY;
#else #else
@ -400,7 +400,7 @@ public class ITERATORS
* @ArrayType(T) * @ArrayType(T)
* @return a Iterator that is wrapping a array. * @return a Iterator that is wrapping a array.
*/ */
public static GENERIC_KEY_BRACES ArrayIterator KEY_GENERIC_TYPE wrap(KEY_TYPE... a) { public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE wrap(KEY_TYPE... a) {
return wrap(a, 0, a.length); return wrap(a, 0, a.length);
} }
@ -412,7 +412,7 @@ public class ITERATORS
* @ArrayType(T) * @ArrayType(T)
* @return a Iterator that is wrapping a array. * @return a Iterator that is wrapping a array.
*/ */
public static GENERIC_KEY_BRACES ArrayIterator KEY_GENERIC_TYPE wrap(KEY_TYPE[] a, int start, int end) { public static GENERIC_KEY_BRACES ITERATOR KEY_GENERIC_TYPE wrap(KEY_TYPE[] a, int start, int end) {
return new ArrayIteratorBRACES(a, start, end); return new ArrayIteratorBRACES(a, start, end);
} }

2
src/builder/resources/speiger/assets/collections/templates/utils/Lists.template
View File

@ -45,7 +45,7 @@ public class LISTS
* @Type(T) * @Type(T)
* @return an empty list * @return an empty list
*/ */
public static GENERIC_KEY_BRACES EmptyList KEY_GENERIC_TYPE empty() { public static GENERIC_KEY_BRACES LIST KEY_GENERIC_TYPE empty() {
#if TYPE_OBJECT #if TYPE_OBJECT
return (EmptyList<KEY_TYPE>)EMPTY; return (EmptyList<KEY_TYPE>)EMPTY;
#else #else

20
src/builder/resources/speiger/assets/collections/templates/utils/Sets.template
View File

@ -371,17 +371,19 @@ public class SETS
@Override @Override
public BI_ITERATOR KEY_GENERIC_TYPE iterator() { return ITERATORS.unmodifiable(s.iterator()); } public BI_ITERATOR KEY_GENERIC_TYPE iterator() { return ITERATORS.unmodifiable(s.iterator()); }
@Override @Override
public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator() { return ITERATORS.unmodifiable(s.reverseIterator()); }
@Override
public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { return ITERATORS.unmodifiable(s.iterator(fromElement)); } public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { return ITERATORS.unmodifiable(s.iterator(fromElement)); }
@Override @Override
public ORDERED_SET KEY_GENERIC_TYPE copy() { return s.copy(); } public ORDERED_SET KEY_GENERIC_TYPE copy() { return s.copy(); }
@Override @Override
public KEY_TYPE FIRST_KEY() { return s.FIRST_KEY(); } public KEY_TYPE GET_FIRST_KEY() { return s.GET_FIRST_KEY(); }
@Override @Override
public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); } public KEY_TYPE REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); }
@Override @Override
public KEY_TYPE LAST_KEY() { return s.LAST_KEY(); } public KEY_TYPE GET_LAST_KEY() { return s.GET_LAST_KEY(); }
@Override @Override
public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); } public KEY_TYPE REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); }
} }
#endif #endif
@ -660,17 +662,19 @@ public class SETS
@Override @Override
public BI_ITERATOR KEY_GENERIC_TYPE iterator() { synchronized(mutex) { return s.iterator(); } } public BI_ITERATOR KEY_GENERIC_TYPE iterator() { synchronized(mutex) { return s.iterator(); } }
@Override @Override
public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator() { synchronized(mutex) { return s.reverseIterator(); } }
@Override
public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { synchronized(mutex) { return s.iterator(fromElement); } } public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { synchronized(mutex) { return s.iterator(fromElement); } }
@Override @Override
public ORDERED_SET KEY_GENERIC_TYPE copy() { synchronized(mutex) { return s.copy(); } } public ORDERED_SET KEY_GENERIC_TYPE copy() { synchronized(mutex) { return s.copy(); } }
@Override @Override
public KEY_TYPE FIRST_KEY() { synchronized(mutex) { return s.FIRST_KEY(); } } public KEY_TYPE GET_FIRST_KEY() { synchronized(mutex) { return s.GET_FIRST_KEY(); } }
@Override @Override
public KEY_TYPE POLL_FIRST_KEY() { synchronized(mutex) { return s.POLL_FIRST_KEY(); } } public KEY_TYPE REMOVE_FIRST_KEY() { synchronized(mutex) { return s.REMOVE_FIRST_KEY(); } }
@Override @Override
public KEY_TYPE LAST_KEY() { synchronized(mutex) { return s.LAST_KEY(); } } public KEY_TYPE GET_LAST_KEY() { synchronized(mutex) { return s.GET_LAST_KEY(); } }
@Override @Override
public KEY_TYPE POLL_LAST_KEY() { synchronized(mutex) { return s.POLL_LAST_KEY(); } } public KEY_TYPE REMOVE_LAST_KEY() { synchronized(mutex) { return s.REMOVE_LAST_KEY(); } }
} }
#endif #endif

49
src/builder/resources/speiger/assets/collections/templates/utils/maps/Maps.template
View File

@ -56,6 +56,9 @@ import speiger.src.collections.PACKAGE.sets.SET;
import speiger.src.collections.PACKAGE.utils.SETS; import speiger.src.collections.PACKAGE.utils.SETS;
#endif #endif
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION; import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION;
#if ORDERED_MAP_FEATURE
import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION;
#endif
#if !SAME_TYPE #if !SAME_TYPE
import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR; import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR;
#endif #endif
@ -553,6 +556,10 @@ public class MAPS
@Override @Override
public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); } public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); }
@Override @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(); } public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); }
@Override @Override
public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); } public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); }
@ -573,13 +580,25 @@ public class MAPS
@Override @Override
public VALUE_TYPE LAST_ENTRY_VALUE() { return map.LAST_ENTRY_VALUE(); } public VALUE_TYPE LAST_ENTRY_VALUE() { return map.LAST_ENTRY_VALUE(); }
@Override @Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { return map.firstEntry(); }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { return map.lastEntry(); }
@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 ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy() { return map.copy(); } public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy() { return map.copy(); }
@Override @Override
public ORDERED_SET KEY_GENERIC_TYPE keySet() { public ORDERED_SET KEY_GENERIC_TYPE keySet() {
if(keys == null) keys = SETS.unmodifiable(map.keySet()); if(keys == null) keys = SETS.unmodifiable(map.keySet());
return (ORDERED_SET KEY_GENERIC_TYPE)keys; return (ORDERED_SET KEY_GENERIC_TYPE)keys;
} }
@Override
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
if(values == null) values = VALUE_COLLECTIONS.unmodifiable(map.values());
return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)values;
}
@Override @Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() { public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySetKV_BRACES(map.ENTRY_SET()); if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySetKV_BRACES(map.ENTRY_SET());
@ -749,15 +768,17 @@ public class MAPS
@Override @Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator() { return ObjectIterators.unmodifiable(set.iterator()); }
@Override @Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); }
@Override
public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } public ObjectBidirectionalIterator<MAP.Entry KEY_VALUE_GENERIC_TYPE> iterator(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); }
@Override @Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE first() { return set.first(); } public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() { return set.getFirst(); }
@Override @Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() { throw new UnsupportedOperationException(); } public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() { throw new UnsupportedOperationException(); }
@Override @Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE last() { return set.last(); } public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() { return set.getLast(); }
@Override @Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() { throw new UnsupportedOperationException(); } public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() { throw new UnsupportedOperationException(); }
} }
#endif #endif
@ -938,6 +959,10 @@ public class MAPS
@Override @Override
public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } }
@Override @Override
public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putFirst(key, value); } }
@Override
public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putLast(key, value); } }
@Override
public boolean moveToFirst(KEY_TYPE key) { synchronized(mutex) { return map.moveToFirst(key); } } public boolean moveToFirst(KEY_TYPE key) { synchronized(mutex) { return map.moveToFirst(key); } }
@Override @Override
public boolean moveToLast(KEY_TYPE key) { synchronized(mutex) { return map.moveToLast(key); } } public boolean moveToLast(KEY_TYPE key) { synchronized(mutex) { return map.moveToLast(key); } }
@ -958,13 +983,25 @@ public class MAPS
@Override @Override
public VALUE_TYPE LAST_ENTRY_VALUE() { synchronized(mutex) { return map.LAST_ENTRY_VALUE(); } } public VALUE_TYPE LAST_ENTRY_VALUE() { synchronized(mutex) { return map.LAST_ENTRY_VALUE(); } }
@Override @Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { synchronized(mutex) { return map.firstEntry(); } }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { synchronized(mutex) { return map.lastEntry(); } }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } }
@Override
public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } }
@Override
public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy() { synchronized(mutex) { return map.copy(); } } public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy() { synchronized(mutex) { return map.copy(); } }
@Override @Override
public ORDERED_SET KEY_GENERIC_TYPE keySet() { public ORDERED_SET KEY_GENERIC_TYPE keySet() {
if(keys == null) keys = SETS.synchronize(map.keySet(), mutex); if(keys == null) keys = SETS.synchronize(map.keySet(), mutex);
return (ORDERED_SET KEY_GENERIC_TYPE)keys; return (ORDERED_SET KEY_GENERIC_TYPE)keys;
} }
@Override
public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() {
if(values == null) values = VALUE_COLLECTIONS.synchronize(map.values(), mutex);
return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)values;
}
@Override @Override
public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() { public ObjectOrderedSet<MAP.Entry KEY_VALUE_GENERIC_TYPE> ENTRY_SET() {
if(entrySet == null) entrySet = ObjectSets.synchronize(map.ENTRY_SET(), mutex); if(entrySet == null) entrySet = ObjectSets.synchronize(map.ENTRY_SET(), mutex);

29
src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template
View File

@ -1,9 +1,14 @@
package speiger.src.testers.PACKAGE.builder.maps; package speiger.src.testers.PACKAGE.builder.maps;
import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Map;
import com.google.common.collect.testing.AbstractTester; import com.google.common.collect.testing.AbstractTester;
import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
import com.google.common.collect.testing.OneSizeTestContainerGenerator;
import com.google.common.collect.testing.features.CollectionFeature; import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.Feature;
import junit.framework.TestSuite; import junit.framework.TestSuite;
import speiger.src.collections.PACKAGE.maps.interfaces.MAP; import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
@ -12,6 +17,7 @@ import speiger.src.testers.PACKAGE.builder.SET_TEST_BUILDER;
import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR; import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR;
import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR; import speiger.src.testers.PACKAGE.generators.TEST_SET_GENERATOR;
import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR; import speiger.src.testers.PACKAGE.generators.maps.TEST_ORDERED_MAP_GENERATOR;
import speiger.src.testers.PACKAGE.impl.maps.DERIVED_MAP_GENERATORS;
import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester; import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapMoveTester;
import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester; import speiger.src.testers.PACKAGE.tests.maps.FILE_KEY_TYPE2FILE_VALUE_TYPEOrderedMapNavigationTester;
#if !TYPE_OBJECT #if !TYPE_OBJECT
@ -20,6 +26,7 @@ import speiger.src.testers.objects.generators.TestObjectSetGenerator;
import speiger.src.testers.objects.builder.ObjectOrderedSetTestSuiteBuilder; import speiger.src.testers.objects.builder.ObjectOrderedSetTestSuiteBuilder;
import speiger.src.testers.objects.generators.TestObjectOrderedSetGenerator; import speiger.src.testers.objects.generators.TestObjectOrderedSetGenerator;
#endif #endif
import speiger.src.testers.utils.SpecialFeature;
@SuppressWarnings("javadoc") @SuppressWarnings("javadoc")
public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE
@ -45,6 +52,15 @@ public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BU
return super.createTestSuite(); return super.createTestSuite();
} }
@Override
protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
if (!parentBuilder.getFeatures().contains(SpecialFeature.DESCENDING)) {
derivedSuites.add(createDescendingSuite(parentBuilder));
}
return derivedSuites;
}
protected ObjectSetTestSuiteBuilder<MAP.Entry KEY_VALUE_GENERIC_TYPE> createDerivedEntrySetSuite(TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> entrySetGenerator) { protected ObjectSetTestSuiteBuilder<MAP.Entry KEY_VALUE_GENERIC_TYPE> createDerivedEntrySetSuite(TestObjectSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE> entrySetGenerator) {
return ObjectOrderedSetTestSuiteBuilder.using((TestObjectOrderedSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE>)entrySetGenerator); return ObjectOrderedSetTestSuiteBuilder.using((TestObjectOrderedSetGenerator<MAP.Entry KEY_VALUE_GENERIC_TYPE>)entrySetGenerator);
} }
@ -52,4 +68,17 @@ public class ORDERED_MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MAP_TEST_BU
protected SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE generator) { protected SET_TEST_BUILDER KEY_GENERIC_TYPE createDerivedKeySetSuite(TEST_SET_GENERATOR KEY_GENERIC_TYPE generator) {
return ORDERED_SET_TEST_BUILDER.using((TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE)generator); return ORDERED_SET_TEST_BUILDER.using((TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE)generator);
} }
private TestSuite createDescendingSuite(FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Map<CLASS_TYPE, CLASS_VALUE_TYPE>, Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>>> parentBuilder) {
TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate = (TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator();
List<Feature<?>> features = new ArrayList<>();
features.add(SpecialFeature.DESCENDING);
features.addAll(parentBuilder.getFeatures());
features.remove(SpecialFeature.COPYING);
features.remove(SpecialFeature.CHILDREN_COPY);
return ORDERED_MAP_TEST_BUILDER.using(new DERIVED_MAP_GENERATORS.DescendingTestOrderedMapGeneratorKV_BRACES(delegate))
.named(parentBuilder.getName() + " reversed").withFeatures(features)
.suppressing(parentBuilder.getSuppressedTests()).createTestSuite();
}
} }

29
src/builder/resources/speiger/assets/testers/templates/impl/maps/DerivedMapGenerators.template
View File

@ -20,6 +20,7 @@ import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP;
import speiger.src.collections.PACKAGE.maps.interfaces.MAP; import speiger.src.collections.PACKAGE.maps.interfaces.MAP;
import speiger.src.collections.PACKAGE.maps.interfaces.MAP.Entry; import speiger.src.collections.PACKAGE.maps.interfaces.MAP.Entry;
import speiger.src.collections.PACKAGE.maps.interfaces.NAVIGABLE_MAP; import speiger.src.collections.PACKAGE.maps.interfaces.NAVIGABLE_MAP;
import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP;
import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP; import speiger.src.collections.PACKAGE.maps.interfaces.SORTED_MAP;
#if !TYPE_OBJECT #if !TYPE_OBJECT
import speiger.src.collections.PACKAGE.sets.SET; import speiger.src.collections.PACKAGE.sets.SET;
@ -206,6 +207,34 @@ public class DERIVED_MAP_GENERATORS {
} }
} }
public static class DescendingTestOrderedMapGenerator KEY_VALUE_GENERIC_TYPE extends MapGenerator KEY_VALUE_GENERIC_TYPE implements TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE {
TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent;
public DescendingTestOrderedMapGenerator(TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent) {
super(parent);
this.parent = parent;
}
@Override
public ORDERED_MAP KEY_VALUE_GENERIC_TYPE create(Entry KEY_VALUE_GENERIC_TYPE... elements) {
return ((ORDERED_MAP KEY_VALUE_GENERIC_TYPE)parent.create(elements)).reversed();
}
@Override
public Iterable<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> order(List<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> insertionOrder) {
ObjectList<Map.Entry<CLASS_TYPE, CLASS_VALUE_TYPE>> values = ObjectIterators.pour(ObjectIterators.wrap(parent.order(insertionOrder).iterator()));
ObjectLists.reverse(values);
return values;
}
@Override
public ObjectIterable<Entry KEY_VALUE_GENERIC_TYPE> order(ObjectList<Entry KEY_VALUE_GENERIC_TYPE> insertionOrder) {
ObjectList<Entry KEY_VALUE_GENERIC_TYPE> values = parent.order(insertionOrder).pourAsList();
ObjectLists.reverse(values);
return values;
}
}
public static class MapGenerator KEY_VALUE_GENERIC_TYPE implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE public static class MapGenerator KEY_VALUE_GENERIC_TYPE implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE
{ {
TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent; TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent;

96
src/builder/resources/speiger/assets/testers/templates/tests/set/OrderedSetMoveTester.template
View File

@ -45,10 +45,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testaddMoveToFirstMissing() public void testaddMoveToFirstMissing()
{ {
assertEquals(a, orderedSet.FIRST_KEY()); assertEquals(a, orderedSet.GET_FIRST_KEY());
assertEquals(true, orderedSet.addAndMoveToFirst(e4())); assertEquals(true, orderedSet.addAndMoveToFirst(e4()));
assertNotEquals(a, orderedSet.FIRST_KEY()); assertNotEquals(a, orderedSet.GET_FIRST_KEY());
assertEquals(e4(), orderedSet.FIRST_KEY()); assertEquals(e4(), orderedSet.GET_FIRST_KEY());
} }
#ignore #ignore
@ -57,10 +57,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testaddMoveToFirstPreset() public void testaddMoveToFirstPreset()
{ {
assertEquals(a, orderedSet.FIRST_KEY()); assertEquals(a, orderedSet.GET_FIRST_KEY());
assertEquals(false, orderedSet.addAndMoveToFirst(c)); assertEquals(false, orderedSet.addAndMoveToFirst(c));
assertNotEquals(a, orderedSet.FIRST_KEY()); assertNotEquals(a, orderedSet.GET_FIRST_KEY());
assertEquals(c, orderedSet.FIRST_KEY()); assertEquals(c, orderedSet.GET_FIRST_KEY());
} }
#ignore #ignore
@ -69,10 +69,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testaddMoveToLastMissing() public void testaddMoveToLastMissing()
{ {
assertEquals(c, orderedSet.LAST_KEY()); assertEquals(c, orderedSet.GET_LAST_KEY());
assertEquals(true, orderedSet.addAndMoveToLast(e4())); assertEquals(true, orderedSet.addAndMoveToLast(e4()));
assertNotEquals(c, orderedSet.LAST_KEY()); assertNotEquals(c, orderedSet.GET_LAST_KEY());
assertEquals(e4(), orderedSet.LAST_KEY()); assertEquals(e4(), orderedSet.GET_LAST_KEY());
} }
#ignore #ignore
@ -81,10 +81,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testaddMoveToLastPreset() public void testaddMoveToLastPreset()
{ {
assertEquals(c, orderedSet.LAST_KEY()); assertEquals(c, orderedSet.GET_LAST_KEY());
assertEquals(false, orderedSet.addAndMoveToLast(a)); assertEquals(false, orderedSet.addAndMoveToLast(a));
assertNotEquals(c, orderedSet.LAST_KEY()); assertNotEquals(c, orderedSet.GET_LAST_KEY());
assertEquals(a, orderedSet.LAST_KEY()); assertEquals(a, orderedSet.GET_LAST_KEY());
} }
#ignore #ignore
@ -93,9 +93,9 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testMoveToFirstMissing() public void testMoveToFirstMissing()
{ {
assertEquals(a, orderedSet.FIRST_KEY()); assertEquals(a, orderedSet.GET_FIRST_KEY());
assertEquals(false, orderedSet.moveToFirst(e4())); assertEquals(false, orderedSet.moveToFirst(e4()));
assertEquals(a, orderedSet.FIRST_KEY()); assertEquals(a, orderedSet.GET_FIRST_KEY());
} }
#ignore #ignore
@ -104,10 +104,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testMoveToFirstPreset() public void testMoveToFirstPreset()
{ {
assertEquals(a, orderedSet.FIRST_KEY()); assertEquals(a, orderedSet.GET_FIRST_KEY());
assertEquals(true, orderedSet.moveToFirst(c)); assertEquals(true, orderedSet.moveToFirst(c));
assertNotEquals(a, orderedSet.FIRST_KEY()); assertNotEquals(a, orderedSet.GET_FIRST_KEY());
assertEquals(c, orderedSet.FIRST_KEY()); assertEquals(c, orderedSet.GET_FIRST_KEY());
} }
#ignore #ignore
@ -116,9 +116,9 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testMoveToLastMissing() public void testMoveToLastMissing()
{ {
assertEquals(c, orderedSet.LAST_KEY()); assertEquals(c, orderedSet.GET_LAST_KEY());
assertEquals(false, orderedSet.moveToLast(e4())); assertEquals(false, orderedSet.moveToLast(e4()));
assertEquals(c, orderedSet.LAST_KEY()); assertEquals(c, orderedSet.GET_LAST_KEY());
} }
#ignore #ignore
@ -127,10 +127,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testMoveToLastPreset() public void testMoveToLastPreset()
{ {
assertEquals(c, orderedSet.LAST_KEY()); assertEquals(c, orderedSet.GET_LAST_KEY());
assertEquals(true, orderedSet.moveToLast(a)); assertEquals(true, orderedSet.moveToLast(a));
assertNotEquals(c, orderedSet.LAST_KEY()); assertNotEquals(c, orderedSet.GET_LAST_KEY());
assertEquals(a, orderedSet.LAST_KEY()); assertEquals(a, orderedSet.GET_LAST_KEY());
} }
#ignore #ignore
@ -139,10 +139,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testMoveCenterToLast() public void testMoveCenterToLast()
{ {
assertEquals(c, orderedSet.LAST_KEY()); assertEquals(c, orderedSet.GET_LAST_KEY());
assertTrue(orderedSet.moveToLast(e1())); assertTrue(orderedSet.moveToLast(e1()));
assertNotEquals(c, orderedSet.LAST_KEY()); assertNotEquals(c, orderedSet.GET_LAST_KEY());
assertEquals(e1(), orderedSet.LAST_KEY()); assertEquals(e1(), orderedSet.GET_LAST_KEY());
} }
#ignore #ignore
@ -151,10 +151,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testMoveCenterToFirst() public void testMoveCenterToFirst()
{ {
assertEquals(a, orderedSet.FIRST_KEY()); assertEquals(a, orderedSet.GET_FIRST_KEY());
assertTrue(orderedSet.moveToFirst(e1())); assertTrue(orderedSet.moveToFirst(e1()));
assertNotEquals(c, orderedSet.FIRST_KEY()); assertNotEquals(c, orderedSet.GET_FIRST_KEY());
assertEquals(e1(), orderedSet.FIRST_KEY()); assertEquals(e1(), orderedSet.GET_FIRST_KEY());
} }
#ignore #ignore
@ -163,13 +163,13 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testMoveForthAndBack() public void testMoveForthAndBack()
{ {
assertEquals(c, orderedSet.LAST_KEY()); assertEquals(c, orderedSet.GET_LAST_KEY());
assertTrue(orderedSet.moveToLast(e0())); assertTrue(orderedSet.moveToLast(e0()));
assertNotEquals(c, orderedSet.LAST_KEY()); assertNotEquals(c, orderedSet.GET_LAST_KEY());
assertEquals(a, orderedSet.LAST_KEY()); assertEquals(a, orderedSet.GET_LAST_KEY());
assertNotEquals(a, orderedSet.FIRST_KEY()); assertNotEquals(a, orderedSet.GET_FIRST_KEY());
assertTrue(orderedSet.moveToFirst(e0())); assertTrue(orderedSet.moveToFirst(e0()));
assertEquals(a, orderedSet.FIRST_KEY()); assertEquals(a, orderedSet.GET_FIRST_KEY());
} }
#ignore #ignore
@ -178,13 +178,13 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testMoveBackAndForth() public void testMoveBackAndForth()
{ {
assertEquals(a, orderedSet.FIRST_KEY()); assertEquals(a, orderedSet.GET_FIRST_KEY());
assertTrue(orderedSet.moveToFirst(e2())); assertTrue(orderedSet.moveToFirst(e2()));
assertNotEquals(a, orderedSet.FIRST_KEY()); assertNotEquals(a, orderedSet.GET_FIRST_KEY());
assertEquals(c, orderedSet.FIRST_KEY()); assertEquals(c, orderedSet.GET_FIRST_KEY());
assertNotEquals(c, orderedSet.LAST_KEY()); assertNotEquals(c, orderedSet.GET_LAST_KEY());
assertTrue(orderedSet.moveToLast(e2())); assertTrue(orderedSet.moveToLast(e2()));
assertEquals(c, orderedSet.LAST_KEY()); assertEquals(c, orderedSet.GET_LAST_KEY());
} }
#ignore #ignore
@ -193,13 +193,13 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testAddForthAndBack() public void testAddForthAndBack()
{ {
assertEquals(c, orderedSet.LAST_KEY()); assertEquals(c, orderedSet.GET_LAST_KEY());
assertFalse(orderedSet.addAndMoveToLast(e0())); assertFalse(orderedSet.addAndMoveToLast(e0()));
assertNotEquals(c, orderedSet.LAST_KEY()); assertNotEquals(c, orderedSet.GET_LAST_KEY());
assertEquals(a, orderedSet.LAST_KEY()); assertEquals(a, orderedSet.GET_LAST_KEY());
assertNotEquals(a, orderedSet.FIRST_KEY()); assertNotEquals(a, orderedSet.GET_FIRST_KEY());
assertFalse(orderedSet.addAndMoveToFirst(e0())); assertFalse(orderedSet.addAndMoveToFirst(e0()));
assertEquals(a, orderedSet.FIRST_KEY()); assertEquals(a, orderedSet.GET_FIRST_KEY());
} }
#ignore #ignore
@ -208,13 +208,13 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT
#endignore #endignore
public void testAddBackAndForth() public void testAddBackAndForth()
{ {
assertEquals(a, orderedSet.FIRST_KEY()); assertEquals(a, orderedSet.GET_FIRST_KEY());
assertFalse(orderedSet.addAndMoveToFirst(e2())); assertFalse(orderedSet.addAndMoveToFirst(e2()));
assertNotEquals(a, orderedSet.FIRST_KEY()); assertNotEquals(a, orderedSet.GET_FIRST_KEY());
assertEquals(c, orderedSet.FIRST_KEY()); assertEquals(c, orderedSet.GET_FIRST_KEY());
assertNotEquals(c, orderedSet.LAST_KEY()); assertNotEquals(c, orderedSet.GET_LAST_KEY());
assertFalse(orderedSet.addAndMoveToLast(e2())); assertFalse(orderedSet.addAndMoveToLast(e2()));
assertEquals(c, orderedSet.LAST_KEY()); assertEquals(c, orderedSet.GET_LAST_KEY());
} }
#ignore #ignore

44
src/builder/resources/speiger/assets/testers/templates/tests/set/OrderedSetNavigationTester.template
View File

@ -68,7 +68,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
int polled = 0; int polled = 0;
int expectedPolls = orderedSet.size(); int expectedPolls = orderedSet.size();
while(polled < expectedPolls) { while(polled < expectedPolls) {
orderedSet.POLL_FIRST_KEY(); orderedSet.REMOVE_FIRST_KEY();
polled++; polled++;
} }
assertTrue("Map should be empty", orderedSet.isEmpty()); assertTrue("Map should be empty", orderedSet.isEmpty());
@ -82,7 +82,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
int polled = 0; int polled = 0;
int expectedPolls = orderedSet.size(); int expectedPolls = orderedSet.size();
while(polled < expectedPolls) { while(polled < expectedPolls) {
orderedSet.POLL_LAST_KEY(); orderedSet.REMOVE_LAST_KEY();
polled++; polled++;
} }
assertTrue("Map should be empty", orderedSet.isEmpty()); assertTrue("Map should be empty", orderedSet.isEmpty());
@ -94,8 +94,8 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
#endignore #endignore
public void testEmptySetPollFirst() { public void testEmptySetPollFirst() {
try { try {
orderedSet.POLL_FIRST_KEY(); orderedSet.REMOVE_FIRST_KEY();
fail("OrderedSet.POLL_FIRST_KEY should throw NoSuchElementException"); fail("OrderedSet.REMOVE_FIRST_KEY should throw NoSuchElementException");
} catch (NoSuchElementException e) { } catch (NoSuchElementException e) {
} }
expectUnchanged(); expectUnchanged();
@ -107,8 +107,8 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
#endignore #endignore
public void testEmptySetPollLast() { public void testEmptySetPollLast() {
try { try {
orderedSet.POLL_LAST_KEY(); orderedSet.REMOVE_LAST_KEY();
fail("OrderedSet.POLL_LAST_KEY should throw NoSuchElementException"); fail("OrderedSet.REMOVE_LAST_KEY should throw NoSuchElementException");
} catch (NoSuchElementException e) { } catch (NoSuchElementException e) {
} }
expectUnchanged(); expectUnchanged();
@ -119,8 +119,8 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
#endignore #endignore
public void testUnsupportedSetPollFirst() { public void testUnsupportedSetPollFirst() {
try { try {
orderedSet.POLL_FIRST_KEY(); orderedSet.REMOVE_FIRST_KEY();
fail("OrderedSet.POLL_FIRST_KEY should throw UnsupportedOperationException"); fail("OrderedSet.REMOVE_FIRST_KEY should throw UnsupportedOperationException");
} catch (UnsupportedOperationException e) { } catch (UnsupportedOperationException e) {
} }
expectUnchanged(); expectUnchanged();
@ -131,8 +131,8 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
#endignore #endignore
public void testUnsupportedSetPollLast() { public void testUnsupportedSetPollLast() {
try { try {
orderedSet.POLL_LAST_KEY(); orderedSet.REMOVE_LAST_KEY();
fail("OrderedSet.POLL_LAST_KEY should throw UnsupportedOperationException"); fail("OrderedSet.REMOVE_LAST_KEY should throw UnsupportedOperationException");
} catch (UnsupportedOperationException e) { } catch (UnsupportedOperationException e) {
} }
expectUnchanged(); expectUnchanged();
@ -143,7 +143,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
@CollectionSize.Require(ONE) @CollectionSize.Require(ONE)
#endignore #endignore
public void testSingletonSetPollFirst() { public void testSingletonSetPollFirst() {
assertEquals(a, orderedSet.POLL_FIRST_KEY()); assertEquals(a, orderedSet.REMOVE_FIRST_KEY());
assertTrue(orderedSet.isEmpty()); assertTrue(orderedSet.isEmpty());
} }
@ -152,7 +152,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
@CollectionSize.Require(ONE) @CollectionSize.Require(ONE)
#endignore #endignore
public void testSingletonSetPollLast() { public void testSingletonSetPollLast() {
assertEquals(a, orderedSet.POLL_LAST_KEY()); assertEquals(a, orderedSet.REMOVE_LAST_KEY());
assertTrue(orderedSet.isEmpty()); assertTrue(orderedSet.isEmpty());
} }
@ -161,7 +161,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
@CollectionSize.Require(SEVERAL) @CollectionSize.Require(SEVERAL)
#endignore #endignore
public void testPollFirst() { public void testPollFirst() {
assertEquals(a, orderedSet.POLL_FIRST_KEY()); assertEquals(a, orderedSet.REMOVE_FIRST_KEY());
assertEquals(values.subList(1, values.size()), HELPERS.copyToList(orderedSet)); assertEquals(values.subList(1, values.size()), HELPERS.copyToList(orderedSet));
} }
@ -170,7 +170,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
@CollectionSize.Require(SEVERAL) @CollectionSize.Require(SEVERAL)
#endignore #endignore
public void testPollLast() { public void testPollLast() {
assertEquals(c, orderedSet.POLL_LAST_KEY()); assertEquals(c, orderedSet.REMOVE_LAST_KEY());
assertEquals(values.subList(0, values.size()-1), HELPERS.copyToList(orderedSet)); assertEquals(values.subList(0, values.size()-1), HELPERS.copyToList(orderedSet));
} }
@ -179,7 +179,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
#endignore #endignore
public void testPollFirstUnsupported() { public void testPollFirstUnsupported() {
try { try {
orderedSet.POLL_FIRST_KEY(); orderedSet.REMOVE_FIRST_KEY();
fail(); fail();
} catch (UnsupportedOperationException e) { } catch (UnsupportedOperationException e) {
} }
@ -190,7 +190,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
#endignore #endignore
public void testPollLastUnsupported() { public void testPollLastUnsupported() {
try { try {
orderedSet.POLL_LAST_KEY(); orderedSet.REMOVE_LAST_KEY();
fail(); fail();
} catch (UnsupportedOperationException e) { } catch (UnsupportedOperationException e) {
} }
@ -201,7 +201,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
#endignore #endignore
public void testEmptySetFirst() { public void testEmptySetFirst() {
try { try {
orderedSet.FIRST_KEY(); orderedSet.GET_FIRST_KEY();
fail(); fail();
} catch (NoSuchElementException e) { } catch (NoSuchElementException e) {
} }
@ -212,7 +212,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
#endignore #endignore
public void testEmptySetLast() { public void testEmptySetLast() {
try { try {
orderedSet.LAST_KEY(); orderedSet.GET_LAST_KEY();
fail(); fail();
} catch (NoSuchElementException e) { } catch (NoSuchElementException e) {
} }
@ -222,27 +222,27 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB
@CollectionSize.Require(ONE) @CollectionSize.Require(ONE)
#endignore #endignore
public void testSingletonSetFirst() { public void testSingletonSetFirst() {
assertEquals(a, orderedSet.FIRST_KEY()); assertEquals(a, orderedSet.GET_FIRST_KEY());
} }
#ignore #ignore
@CollectionSize.Require(ONE) @CollectionSize.Require(ONE)
#endignore #endignore
public void testSingletonSetLast() { public void testSingletonSetLast() {
assertEquals(a, orderedSet.LAST_KEY()); assertEquals(a, orderedSet.GET_LAST_KEY());
} }
#ignore #ignore
@CollectionSize.Require(SEVERAL) @CollectionSize.Require(SEVERAL)
#endignore #endignore
public void testFirst() { public void testFirst() {
assertEquals(a, orderedSet.FIRST_KEY()); assertEquals(a, orderedSet.GET_FIRST_KEY());
} }
#ignore #ignore
@CollectionSize.Require(SEVERAL) @CollectionSize.Require(SEVERAL)
#endignore #endignore
public void testLast() { public void testLast() {
assertEquals(c, orderedSet.LAST_KEY()); assertEquals(c, orderedSet.GET_LAST_KEY());
} }
} }

8
src/test/java/speiger/src/collections/ints/base/BaseIntOrderedSetTest.java
View File

@ -40,8 +40,8 @@ public abstract class BaseIntOrderedSetTest extends BaseIntCollectionTest
public void peekTest() { public void peekTest() {
if(getValidOrderedSetTests().contains(OrderedSetTest.PEEK)) { if(getValidOrderedSetTests().contains(OrderedSetTest.PEEK)) {
IntOrderedSet set = create(TEST_ARRAY); IntOrderedSet set = create(TEST_ARRAY);
Assert.assertEquals(set.firstInt(), 0); Assert.assertEquals(set.getFirstInt(), 0);
Assert.assertEquals(set.lastInt(), 99); Assert.assertEquals(set.getLastInt(), 99);
} }
} }
@ -51,12 +51,12 @@ public abstract class BaseIntOrderedSetTest extends BaseIntCollectionTest
IntOrderedSet set = create(TEST_ARRAY); IntOrderedSet set = create(TEST_ARRAY);
for(int i = 0;i<100;i++) for(int i = 0;i<100;i++)
{ {
Assert.assertEquals(i, set.pollFirstInt()); Assert.assertEquals(i, set.removeFirstInt());
} }
set = create(TEST_ARRAY); set = create(TEST_ARRAY);
for(int i = 99;i>=0;i--) for(int i = 99;i>=0;i--)
{ {
Assert.assertEquals(i, set.pollLastInt()); Assert.assertEquals(i, set.removeLastInt());
} }
} }
} }

1
src/test/java/speiger/src/collections/ints/base/BaseIntPriorityQueueTest.java
View File

@ -113,7 +113,6 @@ public abstract class BaseIntPriorityQueueTest extends BaseIntIterableTest
} }
@Test @Test
@SuppressWarnings("deprecation")
public void testToArray() { public void testToArray() {
if(getValidPriorityQueueTests().contains(PriorityQueueTest.TO_ARRAY)) { if(getValidPriorityQueueTests().contains(PriorityQueueTest.TO_ARRAY)) {
IntPriorityQueue queue = create(EMPTY_ARRAY); IntPriorityQueue queue = create(EMPTY_ARRAY);